Refactor/Rename a bunch of GPU stuff

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 "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 45 matching lines @@
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 TextureManager::~TextureManager() {
   DCHECK(texture_infos_.empty());
 
   // If this triggers, that means something is keeping a reference to
-  // a TextureInfo belonging to this.
+  // a Texture belonging to this.
   CHECK_EQ(texture_info_count_, 0u);
 
   DCHECK_EQ(0, num_unrenderable_textures_);
   DCHECK_EQ(0, num_unsafe_textures_);
   DCHECK_EQ(0, num_uncleared_mips_);
 }
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
   texture_infos_.clear();
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     default_textures_[ii] = NULL;
   }
 
   if (have_context) {
     glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
   }
 
   DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
   DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
 }
 
-TextureManager::TextureInfo::TextureInfo(TextureManager* manager,
+Texture::Texture(TextureManager* manager,
                                          GLuint service_id)
     : manager_(manager),
       service_id_(service_id),
       deleted_(false),
       cleared_(true),
       num_uncleared_mips_(0),
       target_(0),
       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
       mag_filter_(GL_LINEAR),
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
       owned_(true),
       stream_texture_(false),
       immutable_(false),
       estimated_size_(0) {
   if (manager_) {
     manager_->StartTracking(this);
   }
 }
 
-TextureManager::TextureInfo::~TextureInfo() {
+Texture::~Texture() {
   if (manager_) {
     if (owned_ && manager_->have_context_) {
       GLuint id = service_id();
       glDeleteTextures(1, &id);
     }
     MarkAsDeleted();
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
-TextureManager::TextureInfo::LevelInfo::LevelInfo()
+Texture::LevelInfo::LevelInfo()
     : cleared(true),
       target(0),
       level(-1),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
       type(0),
       estimated_size(0) {
 }
 
-TextureManager::TextureInfo::LevelInfo::LevelInfo(const LevelInfo& rhs)
+Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
     : cleared(rhs.cleared),
       target(rhs.target),
       level(rhs.level),
       internal_format(rhs.internal_format),
       width(rhs.width),
       height(rhs.height),
       depth(rhs.depth),
       border(rhs.border),
       format(rhs.format),
       type(rhs.type),
       image(rhs.image),
       estimated_size(rhs.estimated_size) {
 }
 
-TextureManager::TextureInfo::LevelInfo::~LevelInfo() {
+Texture::LevelInfo::~LevelInfo() {
 }
 
-bool TextureManager::TextureInfo::CanRender(
+bool Texture::CanRender(
     const FeatureInfo* feature_info) const {
   if (target_ == 0) {
     return false;
   }
   bool needs_mips = NeedsMips();
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       (target_ == GL_TEXTURE_RECTANGLE_ARB)) {
     return !needs_mips &&
            wrap_s_ == GL_CLAMP_TO_EDGE &&
            wrap_t_ == GL_CLAMP_TO_EDGE;
   }
   if (needs_mips) {
     if (target_ == GL_TEXTURE_2D) {
       return texture_complete();
     } else {
       return texture_complete() && cube_complete();
     }
   } else {
     return true;
   }
 }
 
-void TextureManager::TextureInfo::AddToSignature(
+void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[GLTargetToFaceIndex(target)].size());
-  const TextureInfo::LevelInfo& info =
+  const Texture::LevelInfo& info =
       level_infos_[GLTargetToFaceIndex(target)][level];
   *signature += base::StringPrintf(
       "|Texture|target=%04x|level=%d|internal_format=%04x"
       "|width=%d|height=%d|depth=%d|border=%d|format=%04x|type=%04x"
       "|image=%d|canrender=%d|canrenderto=%d|npot_=%d"
       "|min_filter=%04x|mag_filter=%04x|wrap_s=%04x|wrap_t=%04x"
       "|usage=%04x",
       target, level, info.internal_format,
       info.width, info.height, info.depth, info.border,
       info.format, info.type, info.image.get() != NULL,
       CanRender(feature_info), CanRenderTo(), npot_,
       min_filter_, mag_filter_, wrap_s_, wrap_t_,
       usage_);
 }
 
-bool TextureManager::TextureInfo::MarkMipmapsGenerated(
+bool Texture::MarkMipmapsGenerated(
     const FeatureInfo* feature_info) {
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
-    const TextureInfo::LevelInfo& info1 = level_infos_[ii][0];
+    const Texture::LevelInfo& info1 = level_infos_[ii][0];
     GLsizei width = info1.width;
     GLsizei height = info1.height;
     GLsizei depth = info1.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                FaceIndexToGLTarget(ii);
-    int num_mips = ComputeMipMapCount(width, height, depth);
+    int num_mips = TextureManager::ComputeMipMapCount(width, height, depth);
     for (int level = 1; level < num_mips; ++level) {
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = std::max(1, depth >> 1);
       SetLevelInfo(feature_info,
                    target,
                    level,
                    info1.internal_format,
                    width,
                    height,
                    depth,
                    info1.border,
                    info1.format,
                    info1.type,
                    true);
     }
   }
 
   return true;
 }
 
-void TextureManager::TextureInfo::SetTarget(GLenum target, GLint max_levels) {
+void Texture::SetTarget(GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   level_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     level_infos_[ii].resize(max_levels);
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 }
 
-bool TextureManager::TextureInfo::CanGenerateMipmaps(
+bool Texture::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       level_infos_.empty() ||
       target_ == GL_TEXTURE_EXTERNAL_OES ||
       target_ == GL_TEXTURE_RECTANGLE_ARB) {
     return false;
   }
 
   // Can't generate mips for depth or stencil textures.
-  const TextureInfo::LevelInfo& first = level_infos_[0][0];
+  const Texture::LevelInfo& first = level_infos_[0][0];
   uint32 channels = GLES2Util::GetChannelsForFormat(first.format);
   if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
     return false;
   }
 
   // TODO(gman): Check internal_format, format and type.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
     if ((info.target == 0) ||
         (info.width != first.width) ||
         (info.height != first.height) ||
         (info.depth != 1) ||
         (info.format != first.format) ||
         (info.internal_format != first.internal_format) ||
         (info.type != first.type) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
         info.image) {
         return false;
     }
   }
   return true;
 }
 
-void TextureManager::TextureInfo::SetLevelCleared(GLenum target,
+void Texture::SetLevelCleared(GLenum target,
                                                   GLint level,
                                                   bool cleared) {
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[GLTargetToFaceIndex(target)].size());
-  TextureInfo::LevelInfo& info =
+  Texture::LevelInfo& info =
       level_infos_[GLTargetToFaceIndex(target)][level];
   if (!info.cleared) {
     DCHECK_NE(0, num_uncleared_mips_);
     --num_uncleared_mips_;
   } else {
     ++num_uncleared_mips_;
   }
   info.cleared = cleared;
   UpdateCleared();
 }
 
-void TextureManager::TextureInfo::UpdateCleared() {
+void Texture::UpdateCleared() {
   if (level_infos_.empty()) {
     return;
   }
 
-  const TextureInfo::LevelInfo& first_face = level_infos_[0][0];
-  int levels_needed = ComputeMipMapCount(
+  const Texture::LevelInfo& first_face = level_infos_[0][0];
+  int levels_needed = TextureManager::ComputeMipMapCount(
       first_face.width, first_face.height, first_face.depth);
   cleared_ = true;
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
-      const TextureInfo::LevelInfo& info = level_infos_[ii][jj];
+      const Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.width > 0 && info.height > 0 && info.depth > 0 &&
           !info.cleared) {
         cleared_ = false;
         return;
       }
     }
   }
 }
 
-void TextureManager::TextureInfo::SetLevelInfo(
+void Texture::SetLevelInfo(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[GLTargetToFaceIndex(target)].size());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
-  TextureInfo::LevelInfo& info =
+  Texture::LevelInfo& info =
       level_infos_[GLTargetToFaceIndex(target)][level];
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.width = width;
   info.height = height;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
@@ skipping 10 matching lines @@
   }
   info.cleared = cleared;
   if (!info.cleared) {
     ++num_uncleared_mips_;
   }
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
   UpdateCleared();
 }
 
-bool TextureManager::TextureInfo::ValidForTexture(
+bool Texture::ValidForTexture(
     GLint target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type) const {
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     int32 right;
     int32 top;
     return SafeAddInt32(xoffset, width, &right) &&
            SafeAddInt32(yoffset, height, &top) &&
            xoffset >= 0 &&
            yoffset >= 0 &&
            right <= info.width &&
            top <= info.height &&
            format == info.internal_format &&
            type == info.type;
   }
   return false;
 }
 
-bool TextureManager::TextureInfo::GetLevelSize(
+bool Texture::GetLevelSize(
     GLint target, GLint level, GLsizei* width, GLsizei* height) const {
   DCHECK(width);
   DCHECK(height);
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     if (info.target != 0) {
       *width = info.width;
       *height = info.height;
       return true;
     }
   }
   return false;
 }
 
-bool TextureManager::TextureInfo::GetLevelType(
+bool Texture::GetLevelType(
     GLint target, GLint level, GLenum* type, GLenum* internal_format) const {
   DCHECK(type);
   DCHECK(internal_format);
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     if (info.target != 0) {
       *type = info.type;
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
 
-GLenum TextureManager::TextureInfo::SetParameter(
+GLenum Texture::SetParameter(
     const FeatureInfo* feature_info, GLenum pname, GLint param) {
   DCHECK(feature_info);
 
   if (target_ == GL_TEXTURE_EXTERNAL_OES ||
       target_ == GL_TEXTURE_RECTANGLE_ARB) {
     if (pname == GL_TEXTURE_MIN_FILTER &&
         (param != GL_NEAREST && param != GL_LINEAR))
       return GL_INVALID_ENUM;
     if ((pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T) &&
         param != GL_CLAMP_TO_EDGE)
@@ skipping 46 matching lines @@
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   Update(feature_info);
   UpdateCleared();
   return GL_NO_ERROR;
 }
 
-void TextureManager::TextureInfo::Update(const FeatureInfo* feature_info) {
+void Texture::Update(const FeatureInfo* feature_info) {
   // Update npot status.
   npot_ = false;
 
   if (level_infos_.empty()) {
     texture_complete_ = false;
     cube_complete_ = false;
     return;
   }
 
   // checks that the first mip of any face is npot.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
-    const TextureInfo::LevelInfo& info = level_infos_[ii][0];
+    const Texture::LevelInfo& info = level_infos_[ii][0];
     if (GLES2Util::IsNPOT(info.width) ||
         GLES2Util::IsNPOT(info.height) ||
         GLES2Util::IsNPOT(info.depth)) {
       npot_ = true;
       break;
     }
   }
 
   // Update texture_complete and cube_complete status.
-  const TextureInfo::LevelInfo& first_face = level_infos_[0][0];
-  int levels_needed = ComputeMipMapCount(
+  const Texture::LevelInfo& first_face = level_infos_[0][0];
+  int levels_needed = TextureManager::ComputeMipMapCount(
       first_face.width, first_face.height, first_face.depth);
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (level_infos_.size() == 6) &&
                    (first_face.width == first_face.height);
   if (first_face.width == 0 || first_face.height == 0) {
     texture_complete_ = false;
   }
   if (first_face.type == GL_FLOAT &&
       !feature_info->feature_flags().enable_texture_float_linear &&
       (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
        mag_filter_ != GL_NEAREST)) {
     texture_complete_ = false;
   } else if (first_face.type == GL_HALF_FLOAT_OES &&
              !feature_info->feature_flags().enable_texture_half_float_linear &&
              (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
               mag_filter_ != GL_NEAREST)) {
     texture_complete_ = false;
   }
   for (size_t ii = 0;
        ii < level_infos_.size() && (cube_complete_ || texture_complete_);
        ++ii) {
-    const TextureInfo::LevelInfo& level0 = level_infos_[ii][0];
+    const Texture::LevelInfo& level0 = level_infos_[ii][0];
     if (level0.target == 0 ||
         level0.width != first_face.width ||
         level0.height != first_face.height ||
         level0.depth != 1 ||
         level0.internal_format != first_face.internal_format ||
         level0.format != first_face.format ||
         level0.type != first_face.type) {
       cube_complete_ = false;
     }
     // Get level0 dimensions
     GLsizei width = level0.width;
     GLsizei height = level0.height;
     GLsizei depth = level0.depth;
     for (GLint jj = 1; jj < levels_needed; ++jj) {
       // compute required size for mip.
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = std::max(1, depth >> 1);
-      const TextureInfo::LevelInfo& info = level_infos_[ii][jj];
+      const Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.target == 0 ||
           info.width != width ||
           info.height != height ||
           info.depth != depth ||
           info.internal_format != level0.internal_format ||
           info.format != level0.format ||
           info.type != level0.type) {
         texture_complete_ = false;
         break;
       }
     }
   }
 }
 
-bool TextureManager::TextureInfo::ClearRenderableLevels(GLES2Decoder* decoder) {
+bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
   if (SafeToRenderFrom()) {
     return true;
   }
 
-  const TextureInfo::LevelInfo& first_face = level_infos_[0][0];
-  int levels_needed = ComputeMipMapCount(
+  const Texture::LevelInfo& first_face = level_infos_[0][0];
+  int levels_needed = TextureManager::ComputeMipMapCount(
       first_face.width, first_face.height, first_face.depth);
 
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
-      TextureInfo::LevelInfo& info = level_infos_[ii][jj];
+      Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
   }
   cleared_ = true;
   return true;
 }
 
-bool TextureManager::TextureInfo::IsLevelCleared(GLenum target, GLint level) {
+bool Texture::IsLevelCleared(GLenum target, GLint level) {
   size_t face_index = GLTargetToFaceIndex(target);
   if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
-  TextureInfo::LevelInfo& info = level_infos_[face_index][level];
+  Texture::LevelInfo& info = level_infos_[face_index][level];
 
   return info.cleared;
 }
 
-bool TextureManager::TextureInfo::ClearLevel(
+bool Texture::ClearLevel(
     GLES2Decoder* decoder, GLenum target, GLint level) {
   DCHECK(decoder);
   size_t face_index = GLTargetToFaceIndex(target);
   if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
-  TextureInfo::LevelInfo& info = level_infos_[face_index][level];
+  Texture::LevelInfo& info = level_infos_[face_index][level];
 
   DCHECK(target == info.target);
 
   if (info.target == 0 ||
       info.cleared ||
       info.width == 0 ||
       info.height == 0 ||
       info.depth == 0) {
     return true;
   }
 
   DCHECK_NE(0, num_uncleared_mips_);
   --num_uncleared_mips_;
 
   // NOTE: It seems kind of gross to call back into the decoder for this
   // but only the decoder knows all the state (like unpack_alignment_) that's
   // needed to be able to call GL correctly.
   info.cleared = decoder->ClearLevel(
       service_id_, target_, info.target, info.level, info.format, info.type,
       info.width, info.height, immutable_);
   if (!info.cleared) {
     ++num_uncleared_mips_;
   }
   return info.cleared;
 }
 
-void TextureManager::TextureInfo::SetLevelImage(
+void Texture::SetLevelImage(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[GLTargetToFaceIndex(target)].size());
-  TextureInfo::LevelInfo& info =
+  Texture::LevelInfo& info =
       level_infos_[GLTargetToFaceIndex(target)][level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
 }
 
-gfx::GLImage* TextureManager::TextureInfo::GetLevelImage(
+gfx::GLImage* Texture::GetLevelImage(
   GLint target, GLint level) const {
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     if (info.target != 0) {
       return info.image;
     }
   }
   return 0;
@@ skipping 43 matching lines @@
   }
 
   if (feature_info_->feature_flags().arb_texture_rectangle) {
     default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
   }
 
   return true;
 }
 
-TextureManager::TextureInfo::Ref TextureManager::CreateDefaultAndBlackTextures(
-    GLenum target,
-    GLuint* black_texture) {
+scoped_refptr<Texture>
+    TextureManager::CreateDefaultAndBlackTextures(
+        GLenum target,
+        GLuint* black_texture) {
   static uint8 black[] = {0, 0, 0, 255};
 
   // Sampling a texture not associated with any EGLImage sibling will return
   // black values according to the spec.
   bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
   bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
 
   // Make default textures and texture for replacing non-renderable textures.
   GLuint ids[2];
   glGenTextures(arraysize(ids), ids);
   for (unsigned long ii = 0; ii < arraysize(ids); ++ii) {
     glBindTexture(target, ids[ii]);
     if (needs_initialization) {
       if (needs_faces) {
         for (int jj = 0; jj < GLES2Util::kNumFaces; ++jj) {
           glTexImage2D(GLES2Util::IndexToGLFaceTarget(jj), 0, GL_RGBA, 1, 1, 0,
                        GL_RGBA, GL_UNSIGNED_BYTE, black);
         }
       } else {
         glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
                      GL_UNSIGNED_BYTE, black);
       }
     }
   }
   glBindTexture(target, 0);
 
   // Since we are manually setting up these textures
   // we need to manually manipulate some of the their bookkeeping.
   ++num_unrenderable_textures_;
-  TextureInfo::Ref default_texture = TextureInfo::Ref(
-      new TextureInfo(this, ids[1]));
+  scoped_refptr<Texture> default_texture(new Texture(this, ids[1]));
   SetInfoTarget(default_texture, target);
   if (needs_faces) {
     for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
       SetLevelInfo(
           default_texture, GLES2Util::IndexToGLFaceTarget(ii),
           0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
     }
   } else {
     if (needs_initialization) {
       SetLevelInfo(default_texture,
@@ skipping 23 matching lines @@
          depth <= max_size &&
          (level == 0 || feature_info_->feature_flags().npot_ok ||
           (!GLES2Util::IsNPOT(width) &&
            !GLES2Util::IsNPOT(height) &&
            !GLES2Util::IsNPOT(depth))) &&
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetInfoTarget(
-    TextureManager::TextureInfo* info, GLenum target) {
+    Texture* info, GLenum target) {
   DCHECK(info);
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   info->SetTarget(target, MaxLevelsForTarget(target));
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
 }
 
-void TextureManager::SetLevelCleared(TextureManager::TextureInfo* info,
+void TextureManager::SetLevelCleared(Texture* info,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
   DCHECK(info);
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   info->SetLevelCleared(target, level, cleared);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 bool TextureManager::ClearRenderableLevels(
-    GLES2Decoder* decoder,TextureManager::TextureInfo* info) {
+    GLES2Decoder* decoder,Texture* info) {
   DCHECK(info);
   if (info->SafeToRenderFrom()) {
     return true;
   }
   DCHECK_NE(0, num_unsafe_textures_);
   --num_unsafe_textures_;
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   bool result = info->ClearRenderableLevels(decoder);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 bool TextureManager::ClearTextureLevel(
-    GLES2Decoder* decoder,TextureManager::TextureInfo* info,
+    GLES2Decoder* decoder,Texture* info,
     GLenum target, GLint level) {
   DCHECK(info);
   if (info->num_uncleared_mips() == 0) {
     return true;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   bool result = info->ClearLevel(decoder, target, level);
   info->UpdateCleared();
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 void TextureManager::SetLevelInfo(
-    TextureManager::TextureInfo* info,
+    Texture* info,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
@@ skipping 17 matching lines @@
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
-TextureDefinition* TextureManager::Save(TextureInfo* info) {
+TextureDefinition* TextureManager::Save(Texture* info) {
   DCHECK(info->owned_);
 
   if (info->IsAttachedToFramebuffer())
     return NULL;
 
   TextureDefinition::LevelInfos level_infos(info->level_infos_.size());
   for (size_t face = 0; face < level_infos.size(); ++face) {
     GLenum target = info->target() == GL_TEXTURE_2D ?
         GL_TEXTURE_2D : FaceIndexToGLTarget(face);
     for (size_t level = 0; level < info->level_infos_[face].size(); ++level) {
-      const TextureInfo::LevelInfo& level_info =
+      const Texture::LevelInfo& level_info =
           info->level_infos_[face][level];
       level_infos[face].push_back(
           TextureDefinition::LevelInfo(target,
                                        level_info.internal_format,
                                        level_info.width,
                                        level_info.height,
                                        level_info.depth,
                                        level_info.border,
                                        level_info.format,
                                        level_info.type,
@@ skipping 25 matching lines @@
                                old_service_id,
                                info->min_filter(),
                                info->mag_filter(),
                                info->wrap_s(),
                                info->wrap_t(),
                                info->usage(),
                                immutable,
                                level_infos);
 }
 
-bool TextureManager::Restore(TextureInfo* info,
+bool TextureManager::Restore(Texture* info,
                              TextureDefinition* definition) {
   DCHECK(info->owned_);
 
   scoped_ptr<TextureDefinition> scoped_definition(definition);
 
   if (info->IsAttachedToFramebuffer())
     return false;
 
   if (info->target() != definition->target())
     return false;
@@ skipping 31 matching lines @@
   SetParameter(info, GL_TEXTURE_MIN_FILTER, definition->min_filter());
   SetParameter(info, GL_TEXTURE_MAG_FILTER, definition->mag_filter());
   SetParameter(info, GL_TEXTURE_WRAP_S, definition->wrap_s());
   SetParameter(info, GL_TEXTURE_WRAP_T, definition->wrap_t());
   SetParameter(info, GL_TEXTURE_USAGE_ANGLE, definition->usage());
 
   return true;
 }
 
 GLenum TextureManager::SetParameter(
-    TextureManager::TextureInfo* info, GLenum pname, GLint param) {
+    Texture* info, GLenum pname, GLint param) {
   DCHECK(info);
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   GLenum result = info->SetParameter(feature_info_, pname, param);
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
-bool TextureManager::MarkMipmapsGenerated(TextureManager::TextureInfo* info) {
+bool TextureManager::MarkMipmapsGenerated(Texture* info) {
   DCHECK(info);
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   GetMemTracker(info->pool_)->TrackMemFree(info->estimated_size());
   bool result = info->MarkMipmapsGenerated(feature_info_);
   GetMemTracker(info->pool_)->TrackMemAlloc(info->estimated_size());
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
-TextureManager::TextureInfo* TextureManager::CreateTextureInfo(
+Texture* TextureManager::CreateTexture(
     GLuint client_id, GLuint service_id) {
   DCHECK_NE(0u, service_id);
-  TextureInfo::Ref info(new TextureInfo(this, service_id));
+  scoped_refptr<Texture> info(new Texture(this, service_id));
   std::pair<TextureInfoMap::iterator, bool> result =
       texture_infos_.insert(std::make_pair(client_id, info));
   DCHECK(result.second);
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   num_uncleared_mips_ += info->num_uncleared_mips();
   return info.get();
 }
 
-TextureManager::TextureInfo* TextureManager::GetTextureInfo(
+Texture* TextureManager::GetTexture(
     GLuint client_id) const {
   TextureInfoMap::const_iterator it = texture_infos_.find(client_id);
   return it != texture_infos_.end() ? it->second : NULL;
 }
 
-void TextureManager::RemoveTextureInfo(GLuint client_id) {
+void TextureManager::RemoveTexture(GLuint client_id) {
   TextureInfoMap::iterator it = texture_infos_.find(client_id);
   if (it != texture_infos_.end()) {
-    TextureInfo* info = it->second;
+    Texture* info = it->second;
     info->MarkAsDeleted();
     texture_infos_.erase(it);
   }
 }
 
-void TextureManager::StartTracking(TextureManager::TextureInfo* /* texture */) {
+void TextureManager::StartTracking(Texture* /* texture */) {
   ++texture_info_count_;
 }
 
-void TextureManager::StopTracking(TextureManager::TextureInfo* texture) {
+void TextureManager::StopTracking(Texture* texture) {
   --texture_info_count_;
   if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
@@ skipping 27 matching lines @@
   }
   return false;
 }
 
 GLsizei TextureManager::ComputeMipMapCount(
     GLsizei width, GLsizei height, GLsizei depth) {
   return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
 }
 
 void TextureManager::SetLevelImage(
-    TextureManager::TextureInfo* info,
+    Texture* info,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK(info);
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   info->SetLevelImage(feature_info_, target, level, image);
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 void TextureManager::AddToSignature(
-    TextureInfo* info,
+    Texture* info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   info->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
 void TextureManager::AddPendingAsyncPixelTransfer(
-    base::WeakPtr<gfx::AsyncPixelTransferState> state, TextureInfo* info) {
+    base::WeakPtr<gfx::AsyncPixelTransferState> state, Texture* info) {
   pending_async_transfers_.push_back(PendingAsyncTransfer(state,info));
 }
 
 void TextureManager::BindFinishedAsyncPixelTransfers(
     bool* texture_dirty, bool* framebuffer_dirty) {
   DCHECK(texture_dirty);
   DCHECK(framebuffer_dirty);
   *texture_dirty = false;
   *framebuffer_dirty = false;
 
   // Remove finished transfers from the list, while
   // marking whether texture unit 0 or frame_buffer status is dirty.
   while(!pending_async_transfers_.empty()) {
     PendingAsyncTransfer state_info = pending_async_transfers_.front();
     if (!state_info.first.get()) {
-      // The AsyncState is owned by the TextureInfo. So if the
-      // async state is deleted, so is the TextureInfo.
+      // The AsyncState is owned by the Texture. So if the
+      // async state is deleted, so is the Texture.
       pending_async_transfers_.pop_front();
       continue;
     }
     // Terminate early, as all transfers finish in order.
     if (state_info.first->TransferIsInProgress())
       break;
     // If the transfer is finished, bind it to the texture,
-    // update the TextureInfo, and remove it from pending list.
+    // update the Texture, and remove it from pending list.
     *texture_dirty = true;
     *framebuffer_dirty |= state_info.second->IsAttachedToFramebuffer();
     gfx::AsyncTexImage2DParams tex_define_params;
     state_info.second->
         GetAsyncTransferState()->BindTransfer(&tex_define_params);
     SetLevelInfo(
         state_info.second,
         tex_define_params.target,
         tex_define_params.level,
         tex_define_params.internal_format,
         tex_define_params.width,
         tex_define_params.height,
         1, // depth
         tex_define_params.border,
         tex_define_params.format,
         tex_define_params.type,
         true); // cleared
     pending_async_transfers_.pop_front();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu