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

ui/gl/gl_gl_api_implementation.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 "ui/gl/gl_gl_api_implementation.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_state_restorer.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gl_version_info.h"
 
-namespace gfx {
+namespace gl {
 
 // The GL Api being used. This could be g_real_gl or gl_trace_gl
 static GLApi* g_gl = NULL;
 // A GL Api that calls directly into the driver.
 static RealGLApi* g_real_gl = NULL;
 // A GL Api that does nothing but warn about illegal GL calls without a context
 // current.
 static NoContextGLApi* g_no_context_gl = NULL;
 // A GL Api that calls TRACE and then calls another GL api.
 static TraceGLApi* g_trace_gl = NULL;
 // GL version used when initializing dynamic bindings.
 static GLVersionInfo* g_version_info = NULL;
 
 namespace {
 
 static inline GLenum GetInternalFormat(GLenum internal_format) {
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+  if (gl::GetGLImplementation() != gl::kGLImplementationEGLGLES2) {
     if (internal_format == GL_BGRA_EXT || internal_format == GL_BGRA8_EXT)
       return GL_RGBA8;
   }
   return internal_format;
 }
 
 // TODO(epenner): Could the above function be merged into this and removed?
 static inline GLenum GetTexInternalFormat(GLenum internal_format,
                                           GLenum format,
                                           GLenum type) {
   GLenum gl_internal_format = GetInternalFormat(internal_format);
 
   // g_version_info must be initialized when this function is bound.
-  DCHECK(gfx::g_version_info);
-  if (gfx::g_version_info->is_es3) {
+  DCHECK(gl::g_version_info);
+  if (gl::g_version_info->is_es3) {
     if (internal_format == GL_RED_EXT) {
       // GL_EXT_texture_rg case in ES2.
       switch (type) {
         case GL_UNSIGNED_BYTE:
           gl_internal_format = GL_R8_EXT;
           break;
         case GL_HALF_FLOAT_OES:
           gl_internal_format = GL_R16F_EXT;
           break;
         case GL_FLOAT:
@@ skipping 17 matching lines @@
           gl_internal_format = GL_RG32F_EXT;
           break;
         default:
           NOTREACHED();
           break;
       }
       return gl_internal_format;
     }
   }
 
-  if (type == GL_FLOAT && gfx::g_version_info->is_angle &&
-      gfx::g_version_info->is_es && gfx::g_version_info->major_version == 2) {
+  if (type == GL_FLOAT && gl::g_version_info->is_angle &&
+      gl::g_version_info->is_es && gl::g_version_info->major_version == 2) {
     // It's possible that the texture is using a sized internal format, and
     // ANGLE exposing GLES2 API doesn't support those.
     // TODO(oetuaho@nvidia.com): Remove these conversions once ANGLE has the
     // support.
     // http://code.google.com/p/angleproject/issues/detail?id=556
     switch (format) {
       case GL_RGBA:
         gl_internal_format = GL_RGBA;
         break;
       case GL_RGB:
         gl_internal_format = GL_RGB;
         break;
       default:
         break;
     }
   }
 
-  if (gfx::g_version_info->IsAtLeastGL(2, 1) ||
-      gfx::g_version_info->IsAtLeastGLES(3, 0)) {
+  if (gl::g_version_info->IsAtLeastGL(2, 1) ||
+      gl::g_version_info->IsAtLeastGLES(3, 0)) {
     switch (internal_format) {
       case GL_SRGB_EXT:
         gl_internal_format = GL_SRGB8;
         break;
       case GL_SRGB_ALPHA_EXT:
         gl_internal_format = GL_SRGB8_ALPHA8;
         break;
       default:
         break;
     }
   }
 
-  if (gfx::g_version_info->is_es)
+  if (gl::g_version_info->is_es)
     return gl_internal_format;
 
   if (type == GL_FLOAT) {
     switch (internal_format) {
       // We need to map all the unsized internal formats from ES2 clients.
       case GL_RGBA:
         gl_internal_format = GL_RGBA32F_ARB;
         break;
       case GL_RGB:
         gl_internal_format = GL_RGB32F_ARB;
@@ skipping 34 matching lines @@
         break;
     }
   }
 
   return gl_internal_format;
 }
 
 static inline GLenum GetTexFormat(GLenum format) {
   GLenum gl_format = format;
 
-  DCHECK(gfx::g_version_info);
-  if (gfx::g_version_info->IsAtLeastGL(2, 1) ||
-      gfx::g_version_info->IsAtLeastGLES(3, 0)) {
+  DCHECK(gl::g_version_info);
+  if (gl::g_version_info->IsAtLeastGL(2, 1) ||
+      gl::g_version_info->IsAtLeastGLES(3, 0)) {
     switch (format) {
       case GL_SRGB_EXT:
         gl_format = GL_RGB;
         break;
       case GL_SRGB_ALPHA_EXT:
         gl_format = GL_RGBA;
         break;
       default:
         break;
     }
   }
 
   return gl_format;
 }
 
 static inline GLenum GetTexType(GLenum type) {
-   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
-     if (type == GL_HALF_FLOAT_OES)
-       return GL_HALF_FLOAT_ARB;
+  if (gl::GetGLImplementation() != gl::kGLImplementationEGLGLES2) {
+    if (type == GL_HALF_FLOAT_OES)
+      return GL_HALF_FLOAT_ARB;
    }
    return type;
 }
 
 static void GL_BINDING_CALL CustomTexImage2D(
     GLenum target, GLint level, GLint internalformat,
     GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GLenum gl_internal_format = GetTexInternalFormat(
       internalformat, format, type);
@@ skipping 299 matching lines @@
   GLApiBase::glFlushFn();
 }
 
 void RealGLApi::glFinishFn() {
   GLApiBase::glFinishFn();
 }
 
 void RealGLApi::InitializeFilteredExtensions() {
   if (disabled_exts_.size()) {
     filtered_exts_.clear();
-    if (gfx::WillUseGLGetStringForExtensions()) {
+    if (gl::WillUseGLGetStringForExtensions()) {
       filtered_exts_str_ =
           FilterGLExtensionList(reinterpret_cast<const char*>(
                                     GLApiBase::glGetStringFn(GL_EXTENSIONS)),
                                 disabled_exts_);
       filtered_exts_ = base::SplitString(
           filtered_exts_str_, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     } else {
       GLint num_extensions = 0;
       GLApiBase::glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
       for (GLint i = 0; i < num_extensions; ++i) {
@@ skipping 135 matching lines @@
 }
 
 void VirtualGLApi::glFlushFn() {
   GLApiBase::glFlushFn();
 }
 
 void VirtualGLApi::glFinishFn() {
   GLApiBase::glFinishFn();
 }
 
-}  // namespace gfx
+}  // namespace gl