Move code in ui/gl/* from gfx:: to gl::

gpu/config/gpu_info_collector.cc

 // 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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 10 matching lines @@
 #include "gpu/config/gpu_switches.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"
 #include "ui/gl/gl_version_info.h"
 #include "ui/gl/init/gl_factory.h"
 
 namespace {
 
-scoped_refptr<gfx::GLSurface> InitializeGLSurface() {
-  scoped_refptr<gfx::GLSurface> surface(
+scoped_refptr<gl::GLSurface> InitializeGLSurface() {
+  scoped_refptr<gl::GLSurface> surface(
       gl::init::CreateOffscreenGLSurface(gfx::Size()));
   if (!surface.get()) {
-    LOG(ERROR) << "gfx::GLContext::CreateOffscreenGLSurface failed";
+    LOG(ERROR) << "gl::GLContext::CreateOffscreenGLSurface failed";
     return NULL;
   }
 
   return surface;
 }
 
-scoped_refptr<gfx::GLContext> InitializeGLContext(gfx::GLSurface* surface) {
-  scoped_refptr<gfx::GLContext> context(
-      gl::init::CreateGLContext(nullptr, surface, gfx::PreferIntegratedGpu));
+scoped_refptr<gl::GLContext> InitializeGLContext(gl::GLSurface* surface) {
+  scoped_refptr<gl::GLContext> context(
+      gl::init::CreateGLContext(nullptr, surface, gl::PreferIntegratedGpu));
   if (!context.get()) {
     LOG(ERROR) << "gl::init::CreateGLContext failed";
     return NULL;
   }
 
   if (!context->MakeCurrent(surface)) {
-    LOG(ERROR) << "gfx::GLContext::MakeCurrent() failed";
+    LOG(ERROR) << "gl::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)
@@ skipping 32 matching lines @@
   }
   return -1;
 }
 
 }  // namespace anonymous
 
 namespace gpu {
 
 CollectInfoResult CollectGraphicsInfoGL(GPUInfo* gpu_info) {
   TRACE_EVENT0("startup", "gpu_info_collector::CollectGraphicsInfoGL");
-  DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone);
+  DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone);
 
-  scoped_refptr<gfx::GLSurface> surface(InitializeGLSurface());
+  scoped_refptr<gl::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()));
+  scoped_refptr<gl::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_version = GetGLString(GL_VERSION);
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kGpuTestingGLVendor)) {
     gpu_info->gl_vendor =
         command_line->GetSwitchValueASCII(switches::kGpuTestingGLVendor);
   }
   if (command_line->HasSwitch(switches::kGpuTestingGLRenderer)) {
     gpu_info->gl_renderer =
         command_line->GetSwitchValueASCII(switches::kGpuTestingGLRenderer);
   }
   if (command_line->HasSwitch(switches::kGpuTestingGLVersion)) {
     gpu_info->gl_version =
         command_line->GetSwitchValueASCII(switches::kGpuTestingGLVersion);
   }
 
-  gpu_info->gl_extensions = gfx::GetGLExtensionsFromCurrentContext();
+  gpu_info->gl_extensions = gl::GetGLExtensionsFromCurrentContext();
   std::string glsl_version_string = GetGLString(GL_SHADING_LANGUAGE_VERSION);
 
-  gfx::GLVersionInfo gl_info(gpu_info->gl_version.c_str(),
-                             gpu_info->gl_renderer.c_str(),
-                             gpu_info->gl_extensions.c_str());
+  gl::GLVersionInfo gl_info(gpu_info->gl_version.c_str(),
+                            gpu_info->gl_renderer.c_str(),
+                            gpu_info->gl_extensions.c_str());
   GLint max_samples = 0;
   if (gl_info.IsAtLeastGL(3, 0) || gl_info.IsAtLeastGLES(3, 0) ||
       gpu_info->gl_extensions.find("GL_ANGLE_framebuffer_multisample") !=
           std::string::npos ||
       gpu_info->gl_extensions.find("GL_APPLE_framebuffer_multisample") !=
           std::string::npos ||
       gpu_info->gl_extensions.find("GL_EXT_framebuffer_multisample") !=
           std::string::npos ||
       gpu_info->gl_extensions.find("GL_EXT_multisampled_render_to_texture") !=
           std::string::npos ||
       gpu_info->gl_extensions.find("GL_NV_framebuffer_multisample") !=
           std::string::npos) {
     glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
   }
   gpu_info->max_msaa_samples = base::IntToString(max_samples);
   UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.MaxMSAASampleCount", max_samples);
 
-  gfx::GLWindowSystemBindingInfo window_system_binding_info;
+  gl::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_KHR_robustness") != std::string::npos ||
@@ skipping 111 matching lines @@
   for (size_t ii = 0; ii < gpu_info->secondary_gpus.size(); ++ii) {
     if (active_vendor_id == gpu_info->secondary_gpus[ii].vendor_id) {
       gpu_info->secondary_gpus[ii].active = true;
       return;
     }
   }
 }
 
 }  // namespace gpu