blob: 5d7dd5a9c22f69156af83c328a636ac12aef4d5c [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/config/gpu_info_collector.h"
#include <string>
#include <vector>
#include "base/debug/trace_event.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_implementation.h"
#include "ui/gl/gl_surface.h"
namespace {
scoped_refptr<gfx::GLSurface> InitializeGLSurface() {
scoped_refptr<gfx::GLSurface> surface(
gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size()));
if (!surface.get()) {
LOG(ERROR) << "gfx::GLContext::CreateOffscreenGLSurface failed";
return NULL;
}
return surface;
}
scoped_refptr<gfx::GLContext> InitializeGLContext(gfx::GLSurface* surface) {
scoped_refptr<gfx::GLContext> context(
gfx::GLContext::CreateGLContext(NULL,
surface,
gfx::PreferIntegratedGpu));
if (!context.get()) {
LOG(ERROR) << "gfx::GLContext::CreateGLContext failed";
return NULL;
}
if (!context->MakeCurrent(surface)) {
LOG(ERROR) << "gfx::GLContext::MakeCurrent() failed";
return NULL;
}
return context;
}
std::string GetGLString(unsigned int pname) {
const char* gl_string =
reinterpret_cast<const char*>(glGetString(pname));
if (gl_string)
return std::string(gl_string);
return std::string();
}
// Return a version string in the format of "major.minor".
std::string GetVersionFromString(const std::string& version_string) {
size_t begin = version_string.find_first_of("0123456789");
if (begin != std::string::npos) {
size_t end = version_string.find_first_not_of("01234567890.", begin);
std::string sub_string;
if (end != std::string::npos)
sub_string = version_string.substr(begin, end - begin);
else
sub_string = version_string.substr(begin);
std::vector<std::string> pieces;
base::SplitString(sub_string, '.', &pieces);
if (pieces.size() >= 2)
return pieces[0] + "." + pieces[1];
}
return std::string();
}
} // namespace anonymous
namespace gpu {
CollectInfoResult CollectGraphicsInfoGL(GPUInfo* gpu_info) {
TRACE_EVENT0("startup", "gpu_info_collector::CollectGraphicsInfoGL");
DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone);
scoped_refptr<gfx::GLSurface> surface(InitializeGLSurface());
if (!surface.get()) {
LOG(ERROR) << "Could not create surface for info collection.";
return kCollectInfoFatalFailure;
}
scoped_refptr<gfx::GLContext> context(InitializeGLContext(surface.get()));
if (!context.get()) {
LOG(ERROR) << "Could not create context for info collection.";
return kCollectInfoFatalFailure;
}
gpu_info->gl_renderer = GetGLString(GL_RENDERER);
gpu_info->gl_vendor = GetGLString(GL_VENDOR);
gpu_info->gl_extensions = GetGLString(GL_EXTENSIONS);
gpu_info->gl_version = GetGLString(GL_VERSION);
std::string glsl_version_string = GetGLString(GL_SHADING_LANGUAGE_VERSION);
gfx::GLWindowSystemBindingInfo window_system_binding_info;
if (GetGLWindowSystemBindingInfo(&window_system_binding_info)) {
gpu_info->gl_ws_vendor = window_system_binding_info.vendor;
gpu_info->gl_ws_version = window_system_binding_info.version;
gpu_info->gl_ws_extensions = window_system_binding_info.extensions;
gpu_info->direct_rendering = window_system_binding_info.direct_rendering;
}
bool supports_robustness =
gpu_info->gl_extensions.find("GL_EXT_robustness") != std::string::npos ||
gpu_info->gl_extensions.find("GL_ARB_robustness") != std::string::npos;
if (supports_robustness) {
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
reinterpret_cast<GLint*>(&gpu_info->gl_reset_notification_strategy));
}
// TODO(kbr): remove once the destruction of a current context automatically
// clears the current context.
context->ReleaseCurrent(surface.get());
std::string glsl_version = GetVersionFromString(glsl_version_string);
gpu_info->pixel_shader_version = glsl_version;
gpu_info->vertex_shader_version = glsl_version;
return CollectDriverInfoGL(gpu_info);
}
void MergeGPUInfoGL(GPUInfo* basic_gpu_info,
const GPUInfo& context_gpu_info) {
DCHECK(basic_gpu_info);
basic_gpu_info->gl_renderer = context_gpu_info.gl_renderer;
basic_gpu_info->gl_vendor = context_gpu_info.gl_vendor;
basic_gpu_info->gl_version = context_gpu_info.gl_version;
basic_gpu_info->gl_extensions = context_gpu_info.gl_extensions;
basic_gpu_info->pixel_shader_version =
context_gpu_info.pixel_shader_version;
basic_gpu_info->vertex_shader_version =
context_gpu_info.vertex_shader_version;
basic_gpu_info->gl_ws_vendor = context_gpu_info.gl_ws_vendor;
basic_gpu_info->gl_ws_version = context_gpu_info.gl_ws_version;
basic_gpu_info->gl_ws_extensions = context_gpu_info.gl_ws_extensions;
basic_gpu_info->gl_reset_notification_strategy =
context_gpu_info.gl_reset_notification_strategy;
if (!context_gpu_info.driver_vendor.empty())
basic_gpu_info->driver_vendor = context_gpu_info.driver_vendor;
if (!context_gpu_info.driver_version.empty())
basic_gpu_info->driver_version = context_gpu_info.driver_version;
basic_gpu_info->can_lose_context = context_gpu_info.can_lose_context;
basic_gpu_info->sandboxed = context_gpu_info.sandboxed;
basic_gpu_info->direct_rendering = context_gpu_info.direct_rendering;
basic_gpu_info->finalized = context_gpu_info.finalized;
basic_gpu_info->initialization_time = context_gpu_info.initialization_time;
}
} // namespace gpu