ui/gl: Move GLImage into gl namespace.

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 1222 matching lines @@
     }
   }
 
   UpdateMipCleared(&info, info.width, info.height,
                    gfx::Rect(info.width, info.height));
   return true;
 }
 
 void Texture::SetLevelImage(GLenum target,
                             GLint level,
-                            gfx::GLImage* image,
+                            gl::GLImage* image,
                             ImageState state) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
   info.image_state = state;
   UpdateCanRenderCondition();
   UpdateHasImages();
 }
 
-gfx::GLImage* Texture::GetLevelImage(GLint target,
-                                     GLint level,
-                                     ImageState* state) const {
+gl::GLImage* Texture::GetLevelImage(GLint target,
+                                    GLint level,
+                                    ImageState* state) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     if (info.target != 0) {
       if (state)
         *state = info.image_state;
       return info.image.get();
     }
   }
   return NULL;
 }
 
-gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
+gl::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   return GetLevelImage(target, level, nullptr);
 }
 
 void Texture::DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
                               uint64_t client_tracing_id,
                               const std::string& dump_name) const {
   for (uint32_t face_index = 0; face_index < face_infos_.size(); ++face_index) {
     const auto& level_infos = face_infos_[face_index].level_infos;
     for (uint32_t level_index = 0; level_index < level_infos.size();
          ++level_index) {
@@ skipping 425 matching lines @@
       return 1;
     default:
       return 1 +
              base::bits::Log2Floor(std::max(std::max(width, height), depth));
   }
 }
 
 void TextureManager::SetLevelImage(TextureRef* ref,
                                    GLenum target,
                                    GLint level,
-                                   gfx::GLImage* image,
+                                   gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(target, level, image, state);
 }
 
 size_t TextureManager::GetSignatureSize() const {
   return sizeof(TextureTag) + sizeof(TextureSignature);
 }
 
 void TextureManager::AddToSignature(
@@ skipping 424 matching lines @@
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
 
   // Dump all sub-levels held by the texture. They will appear below the main
   // gl/textures/client_X/texture_Y dump.
   ref->texture()->DumpLevelMemory(pmd, memory_tracker_->ClientTracingId(),
                                   dump_name);
 }
 
 }  // namespace gles2
 }  // namespace gpu