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

gpu/command_buffer/service/texture_manager.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/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1614 matching lines @@
   // Take no action if this isn't an OES_EXTERNAL texture.
   if (target_ && target_ != GL_TEXTURE_EXTERNAL_OES)
     return;
 
   if (!service_id)
     new_service_id = owned_service_id_;
 
   if (service_id_ != new_service_id) {
     service_id_ = new_service_id;
     IncrementManagerServiceIdGeneration();
-    if (gfx::GLContext* context = gfx::GLContext::GetCurrent()) {
+    if (gl::GLContext* context = gl::GLContext::GetCurrent()) {
       // It would be preferable to pass in the decoder, and ask it to do this
       // instead.  However, there are several cases, such as TextureDefinition,
       // that show up without a clear context owner.  So, instead, we use the
       // current state's state restorer.
-      if (gfx::GLStateRestorer* restorer = context->GetGLStateRestorer())
+      if (gl::GLStateRestorer* restorer = context->GetGLStateRestorer())
         restorer->RestoreAllExternalTextureBindingsIfNeeded();
     }
   }
 }
 
 GLenum Texture::GetCompatibilitySwizzleForChannel(GLenum channel) {
   return GetSwizzleForChannel(channel, compatibility_swizzle_);
 }
 
 void Texture::SetCompatibilitySwizzle(const CompatibilitySwizzle* swizzle) {
@@ skipping 1185 matching lines @@
         GetCompatibilitySwizzle(format);
     if (swizzle)
       return swizzle->dest_format;
   }
   return format;
 }
 
 GLenum TextureManager::AdjustTexFormat(GLenum format) const {
   // TODO(bajones): GLES 3 allows for internal format and format to differ.
   // This logic may need to change as a result.
-  if (gfx::GetGLImplementation() == gfx::kGLImplementationDesktopGL) {
+  if (gl::GetGLImplementation() == gl::kGLImplementationDesktopGL) {
     if (format == GL_SRGB_EXT)
       return GL_RGB;
     if (format == GL_SRGB_ALPHA_EXT)
       return GL_RGBA;
   }
   if (feature_info_->gl_version_info().is_desktop_core_profile) {
     const Texture::CompatibilitySwizzle* swizzle =
         GetCompatibilitySwizzle(format);
     if (swizzle)
       return swizzle->dest_format;
@@ skipping 161 matching lines @@
                          memory_tracker_->ClientId(), ref->client_id());
 
   base::trace_event::MemoryAllocatorDump* dump =
       pmd->CreateAllocatorDump(dump_name);
   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                   static_cast<uint64_t>(size));
 
   // Add the |client_guid| which expresses shared ownership with the client
   // process.
-  auto client_guid = gfx::GetGLTextureClientGUIDForTracing(
+  auto client_guid = gl::GetGLTextureClientGUIDForTracing(
       memory_tracker_->ShareGroupTracingGUID(), ref->client_id());
   pmd->CreateSharedGlobalAllocatorDump(client_guid);
   pmd->AddOwnershipEdge(dump->guid(), client_guid);
 
   // Add a |service_guid| which expresses shared ownership between the various
   // |client_guid|s.
   // TODO(ericrk): May need to ensure uniqueness using GLShareGroup and
   // potentially cross-share-group sharing via EGLImages. crbug.com/512534
-  auto service_guid = gfx::GetGLTextureServiceGUIDForTracing(
+  auto service_guid = gl::GetGLTextureServiceGUIDForTracing(
       memory_tracker_->ShareGroupTracingGUID(), ref->texture()->service_id());
   pmd->CreateSharedGlobalAllocatorDump(service_guid);
 
   int importance = 0;  // Default importance.
   // The link to the memory tracking |client_id| is given a higher importance
   // than other refs.
   if (ref == ref->texture()->memory_tracking_ref_)
     importance = 2;
 
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
@@ skipping 261 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu