Home | History | Annotate | Download | only in config
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/config/gpu_info_collector.h"
      6 
      7 #include <string>
      8 #include <vector>
      9 
     10 #include "base/debug/trace_event.h"
     11 #include "base/logging.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/strings/string_number_conversions.h"
     14 #include "base/strings/string_piece.h"
     15 #include "base/strings/string_split.h"
     16 #include "ui/gl/gl_bindings.h"
     17 #include "ui/gl/gl_context.h"
     18 #include "ui/gl/gl_implementation.h"
     19 #include "ui/gl/gl_surface.h"
     20 
     21 namespace {
     22 
     23 scoped_refptr<gfx::GLSurface> InitializeGLSurface() {
     24   scoped_refptr<gfx::GLSurface> surface(
     25       gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1)));
     26   if (!surface.get()) {
     27     LOG(ERROR) << "gfx::GLContext::CreateOffscreenGLSurface failed";
     28     return NULL;
     29   }
     30 
     31   return surface;
     32 }
     33 
     34 scoped_refptr<gfx::GLContext> InitializeGLContext(gfx::GLSurface* surface) {
     35 
     36   scoped_refptr<gfx::GLContext> context(
     37       gfx::GLContext::CreateGLContext(NULL,
     38                                       surface,
     39                                       gfx::PreferIntegratedGpu));
     40   if (!context.get()) {
     41     LOG(ERROR) << "gfx::GLContext::CreateGLContext failed";
     42     return NULL;
     43   }
     44 
     45   if (!context->MakeCurrent(surface)) {
     46     LOG(ERROR) << "gfx::GLContext::MakeCurrent() failed";
     47     return NULL;
     48   }
     49 
     50   return context;
     51 }
     52 
     53 std::string GetGLString(unsigned int pname) {
     54   const char* gl_string =
     55       reinterpret_cast<const char*>(glGetString(pname));
     56   if (gl_string)
     57     return std::string(gl_string);
     58   return std::string();
     59 }
     60 
     61 // Return a version string in the format of "major.minor".
     62 std::string GetVersionFromString(const std::string& version_string) {
     63   size_t begin = version_string.find_first_of("0123456789");
     64   if (begin != std::string::npos) {
     65     size_t end = version_string.find_first_not_of("01234567890.", begin);
     66     std::string sub_string;
     67     if (end != std::string::npos)
     68       sub_string = version_string.substr(begin, end - begin);
     69     else
     70       sub_string = version_string.substr(begin);
     71     std::vector<std::string> pieces;
     72     base::SplitString(sub_string, '.', &pieces);
     73     if (pieces.size() >= 2)
     74       return pieces[0] + "." + pieces[1];
     75   }
     76   return std::string();
     77 }
     78 
     79 }  // namespace anonymous
     80 
     81 namespace gpu {
     82 
     83 bool CollectGraphicsInfoGL(GPUInfo* gpu_info) {
     84   TRACE_EVENT0("startup", "gpu_info_collector::CollectGraphicsInfoGL");
     85   if (!gfx::GLSurface::InitializeOneOff()) {
     86     LOG(ERROR) << "gfx::GLSurface::InitializeOneOff() failed";
     87     return false;
     88   }
     89 
     90   scoped_refptr<gfx::GLSurface> surface(InitializeGLSurface());
     91   if (!surface.get())
     92     return false;
     93 
     94   scoped_refptr<gfx::GLContext> context(InitializeGLContext(surface.get()));
     95   if (!context.get())
     96     return false;
     97 
     98   gpu_info->gl_renderer = GetGLString(GL_RENDERER);
     99   gpu_info->gl_vendor = GetGLString(GL_VENDOR);
    100   gpu_info->gl_extensions = GetGLString(GL_EXTENSIONS);
    101   gpu_info->gl_version_string = GetGLString(GL_VERSION);
    102   std::string glsl_version_string = GetGLString(GL_SHADING_LANGUAGE_VERSION);
    103 
    104   gfx::GLWindowSystemBindingInfo window_system_binding_info;
    105   if (GetGLWindowSystemBindingInfo(&window_system_binding_info)) {
    106     gpu_info->gl_ws_vendor = window_system_binding_info.vendor;
    107     gpu_info->gl_ws_version = window_system_binding_info.version;
    108     gpu_info->gl_ws_extensions = window_system_binding_info.extensions;
    109   }
    110 
    111   bool supports_robustness =
    112       gpu_info->gl_extensions.find("GL_EXT_robustness") != std::string::npos ||
    113       gpu_info->gl_extensions.find("GL_ARB_robustness") != std::string::npos;
    114   if (supports_robustness) {
    115     glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
    116         reinterpret_cast<GLint*>(&gpu_info->gl_reset_notification_strategy));
    117   }
    118 
    119   // TODO(kbr): remove once the destruction of a current context automatically
    120   // clears the current context.
    121   context->ReleaseCurrent(surface.get());
    122 
    123   gpu_info->gl_version = GetVersionFromString(gpu_info->gl_version_string);
    124   std::string glsl_version = GetVersionFromString(glsl_version_string);
    125   gpu_info->pixel_shader_version = glsl_version;
    126   gpu_info->vertex_shader_version = glsl_version;
    127 
    128   return CollectDriverInfoGL(gpu_info);
    129 }
    130 
    131 void MergeGPUInfoGL(GPUInfo* basic_gpu_info,
    132                     const GPUInfo& context_gpu_info) {
    133   DCHECK(basic_gpu_info);
    134   basic_gpu_info->gl_renderer = context_gpu_info.gl_renderer;
    135   basic_gpu_info->gl_vendor = context_gpu_info.gl_vendor;
    136   basic_gpu_info->gl_version_string = context_gpu_info.gl_version_string;
    137   basic_gpu_info->gl_extensions = context_gpu_info.gl_extensions;
    138   basic_gpu_info->gl_version = context_gpu_info.gl_version;
    139   basic_gpu_info->pixel_shader_version =
    140       context_gpu_info.pixel_shader_version;
    141   basic_gpu_info->vertex_shader_version =
    142       context_gpu_info.vertex_shader_version;
    143   basic_gpu_info->gl_ws_vendor = context_gpu_info.gl_ws_vendor;
    144   basic_gpu_info->gl_ws_version = context_gpu_info.gl_ws_version;
    145   basic_gpu_info->gl_ws_extensions = context_gpu_info.gl_ws_extensions;
    146   basic_gpu_info->gl_reset_notification_strategy =
    147       context_gpu_info.gl_reset_notification_strategy;
    148 
    149   if (!context_gpu_info.driver_vendor.empty())
    150     basic_gpu_info->driver_vendor = context_gpu_info.driver_vendor;
    151   if (!context_gpu_info.driver_version.empty())
    152     basic_gpu_info->driver_version = context_gpu_info.driver_version;
    153 
    154   basic_gpu_info->can_lose_context = context_gpu_info.can_lose_context;
    155   basic_gpu_info->sandboxed = context_gpu_info.sandboxed;
    156   basic_gpu_info->finalized = context_gpu_info.finalized;
    157   basic_gpu_info->initialization_time = context_gpu_info.initialization_time;
    158 }
    159 
    160 }  // namespace gpu
    161 
    162