gpu: Refactor to support cross-channel shared textures

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/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 
 namespace gpu {
 namespace gles2 {
 
 static size_t GLTargetToFaceIndex(GLenum target) {
   switch (target) {
@@ skipping 59 matching lines @@
   }
 
   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());
 }
 
-Texture::Texture(TextureManager* manager, GLuint service_id)
-    : manager_(manager),
+Texture::Texture(GLuint service_id)
+    : memory_tracking_ref_(NULL),
       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);
+      estimated_size_(0),
+      can_render_condition_(CAN_RENDER_NEVER) {
+}
+
+Texture::~Texture() {
+}
+
+void Texture::AddTextureRef(TextureRef* ref) {
+  DCHECK(refs_.find(ref) == refs_.end());
+  refs_.insert(ref);
+  if (!memory_tracking_ref_) {
+    memory_tracking_ref_ = ref;
+    GetMemTracker()->TrackMemAlloc(estimated_size());
   }
 }
 
-Texture::~Texture() {
-  if (manager_) {
-    if (owned_ && manager_->have_context_) {
+void Texture::RemoveTextureRef(TextureRef* ref, bool have_context) {
+  if (memory_tracking_ref_ == ref) {
+    GetMemTracker()->TrackMemFree(estimated_size());
+    memory_tracking_ref_ = NULL;
+  }
+  size_t result = refs_.erase(ref);
+  DCHECK_EQ(result, 1u);
+  if (refs_.empty()) {
+    if (owned_ && have_context) {
       GLuint id = service_id();
       glDeleteTextures(1, &id);
     }
-    MarkAsDeleted();
-    manager_->StopTracking(this);
-    manager_ = NULL;
+    delete this;
+  } else if (memory_tracking_ref_ == NULL) {
+    // TODO(piman): tune ownership semantics for cross-context group shared
+    // textures.
+    memory_tracking_ref_ = *refs_.begin();
+    GetMemTracker()->TrackMemAlloc(estimated_size());
   }
 }
 
+MemoryTypeTracker* Texture::GetMemTracker() {
+  DCHECK(memory_tracking_ref_);
+  return memory_tracking_ref_->manager()->GetMemTracker(pool_);
+}
+
 Texture::LevelInfo::LevelInfo()
     : cleared(true),
       target(0),
       level(-1),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
@@ skipping 12 matching lines @@
       border(rhs.border),
       format(rhs.format),
       type(rhs.type),
       image(rhs.image),
       estimated_size(rhs.estimated_size) {
 }
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
+Texture::CanRenderCondition Texture::GetCanRenderCondition() const {

[piman, 2013/05/14 01:34:50]

Note: this function should encode the logic that was in Texture::CanRender.
Because it needs to return a feature-independent value, the order of tests
changed a bit, but it should be functionally identical (verified with tests).

+  if (target_ == 0)
+    return CAN_RENDER_NEVER;
+
+  bool needs_mips = NeedsMips();
+  if (needs_mips) {
+    if (!texture_complete())
+      return CAN_RENDER_NEVER;
+    if (target_ == GL_TEXTURE_CUBE_MAP && !cube_complete())
+      return CAN_RENDER_NEVER;
+  }
+
+  bool is_npot_compatible = !needs_mips &&
+      wrap_s_ == GL_CLAMP_TO_EDGE &&
+      wrap_t_ == GL_CLAMP_TO_EDGE;
+
+  if (!is_npot_compatible) {
+    if (target_ == GL_TEXTURE_RECTANGLE_ARB)
+      return CAN_RENDER_NEVER;
+    else if (npot())
+      return CAN_RENDER_ONLY_IF_NPOT;
+  }
+
+  return CAN_RENDER_ALWAYS;
+}
+
 bool Texture::CanRender(const FeatureInfo* feature_info) const {
-  if (target_ == 0) {
-    return false;
+  switch (can_render_condition_) {
+    case CAN_RENDER_ALWAYS:
+      return true;
+    case CAN_RENDER_NEVER:
+      return false;
+    case CAN_RENDER_ONLY_IF_NPOT:
+      break;
   }
-  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;
-  }
+  return feature_info->feature_flags().npot_ok;
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   DCHECK_GE(level, 0);
@@ skipping 61 matching lines @@
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     immutable_ = true;
   }
+  UpdateCanRenderCondition();
 }
 
 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;
   }
@@ skipping 25 matching lines @@
 }
 
 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());
   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;
+  UpdateMipCleared(&info, cleared);
   UpdateCleared();
 }
 
 void Texture::UpdateCleared() {
   if (level_infos_.empty()) {
     return;
   }
 
   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;
+  bool cleared = true;
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
       const Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.width > 0 && info.height > 0 && info.depth > 0 &&
           !info.cleared) {
-        cleared_ = false;
-        return;
+        cleared = false;
+        break;
       }
     }
   }
+  UpdateSafeToRenderFrom(cleared);
+}
+
+void Texture::UpdateSafeToRenderFrom(bool cleared) {
+  if (cleared_ == cleared)
+    return;
+  cleared_ = cleared;
+  int delta = cleared ? -1 : +1;
+  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
+    (*it)->manager()->UpdateSafeToRenderFrom(delta);
+}
+
+void Texture::UpdateMipCleared(LevelInfo* info, bool cleared) {
+  if (info->cleared == cleared)
+    return;
+  info->cleared = cleared;
+  int delta = cleared ? -1 : +1;
+  num_uncleared_mips_ += delta;
+  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
+    (*it)->manager()->UpdateUnclearedMips(delta);
+}
+
+void Texture::UpdateCanRenderCondition() {
+  CanRenderCondition can_render_condition = GetCanRenderCondition();
+  if (can_render_condition_ == can_render_condition)
+    return;
+  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
+    (*it)->manager()->UpdateCanRenderCondition(can_render_condition_,
+                                               can_render_condition);
+  can_render_condition_ = can_render_condition;
+}
+
+void Texture::IncAllFramebufferStateChangeCount() {
+  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
+    (*it)->manager()->IncFramebufferStateChangeCount();
+}
+
+AsyncPixelTransferState* Texture::GetAsyncTransferState() const {
+  for (RefSet::const_iterator it = refs_.begin(); it != refs_.end(); ++it) {
+    AsyncPixelTransferState* state = (*it)->async_transfer_state();
+    if (state)
+      return state;
+  }
+  return NULL;
 }
 
 void Texture::SetLevelInfo(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
@@ skipping 20 matching lines @@
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
-  if (!info.cleared) {
-    DCHECK_NE(0, num_uncleared_mips_);
-    --num_uncleared_mips_;
-  }
-  info.cleared = cleared;
-  if (!info.cleared) {
-    ++num_uncleared_mips_;
-  }
+  UpdateMipCleared(&info, cleared);
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
   UpdateCleared();
+  UpdateCanRenderCondition();
+  if (IsAttachedToFramebuffer()) {
+    // TODO(gman): If textures tracked which framebuffers they were attached to
+    // we could just mark those framebuffers as not complete.
+    IncAllFramebufferStateChangeCount();
+  }
 }
 
 bool Texture::ValidForTexture(
     GLint target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
@@ skipping 74 matching lines @@
     case GL_TEXTURE_MAG_FILTER:
       if (!feature_info->validators()->texture_mag_filter_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       mag_filter_ = param;
       break;
     case GL_TEXTURE_POOL_CHROMIUM:
       if (!feature_info->validators()->texture_pool.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      manager_->GetMemTracker(pool_)->TrackMemFree(estimated_size());
+      GetMemTracker()->TrackMemFree(estimated_size());
       pool_ = param;
-      manager_->GetMemTracker(pool_)->TrackMemAlloc(estimated_size());
+      GetMemTracker()->TrackMemAlloc(estimated_size());
       break;
     case GL_TEXTURE_WRAP_S:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       wrap_s_ = param;
       break;
     case GL_TEXTURE_WRAP_T:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
@@ skipping 10 matching lines @@
         return GL_INVALID_ENUM;
       }
       usage_ = param;
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   Update(feature_info);
   UpdateCleared();
+  UpdateCanRenderCondition();
   return GL_NO_ERROR;
 }
 
 void Texture::Update(const FeatureInfo* feature_info) {
   // Update npot status.
   npot_ = false;
 
   if (level_infos_.empty()) {
     texture_complete_ = false;
     cube_complete_ = false;
@@ skipping 66 matching lines @@
           info.type != level0.type) {
         texture_complete_ = false;
         break;
       }
     }
   }
 }
 
 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
-  if (SafeToRenderFrom()) {
+  if (cleared_) {
     return true;
   }
 
   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) {
       Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
   }
-  cleared_ = true;
+  UpdateSafeToRenderFrom(true);
   return true;
 }
 
 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
   size_t face_index = GLTargetToFaceIndex(target);
   if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
@@ skipping 16 matching lines @@
   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(
+  bool 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_;
-  }
+  UpdateMipCleared(&info, cleared);
   return info.cleared;
 }
 
 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());
   Texture::LevelInfo& info =
       level_infos_[GLTargetToFaceIndex(target)][level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
+  UpdateCanRenderCondition();
 }
 
 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;
 }
 
+
+TextureRef::TextureRef(TextureManager* manager, Texture* texture)
+    : manager_(manager),
+      texture_(texture) {
+  DCHECK(manager_);
+  DCHECK(texture_);
+  texture_->AddTextureRef(this);
+  manager_->StartTracking(this);
+}
+
+scoped_refptr<TextureRef> TextureRef::Create(TextureManager* manager,
+                                             GLuint service_id) {
+  return new TextureRef(manager, new Texture(service_id));
+}
+
+TextureRef::~TextureRef() {
+  manager_->StopTracking(this);
+  texture_->RemoveTextureRef(this, manager_->have_context_);
+  manager_ = NULL;
+}
+
+
 TextureManager::TextureManager(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info,
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
     : memory_tracker_managed_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
       memory_tracker_unmanaged_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       feature_info_(feature_info),
+      framebuffer_manager_(NULL),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_levels_(ComputeMipMapCount(max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
       max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
@@ skipping 21 matching lines @@
   }
 
   if (feature_info_->feature_flags().arb_texture_rectangle) {
     default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
   }
 
   return true;
 }
 
-scoped_refptr<Texture>
+scoped_refptr<TextureRef>
     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_;
-  scoped_refptr<Texture> default_texture(new Texture(this, ids[1]));
+  scoped_refptr<TextureRef> default_texture(TextureRef::Create(this, ids[1]));
   SetTarget(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 22 matching lines @@
          height <= max_size &&
          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::SetTarget(Texture* texture, GLenum target) {
-  DCHECK(texture);
-  if (!texture->CanRender(feature_info_)) {
-    DCHECK_NE(0, num_unrenderable_textures_);
-    --num_unrenderable_textures_;
-  }
-  texture->SetTarget(target, MaxLevelsForTarget(target));
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
+void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
+  DCHECK(ref);
+  ref->texture()->SetTarget(target, MaxLevelsForTarget(target));
 }
 
-void TextureManager::SetLevelCleared(Texture* texture,
+void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
-  DCHECK(texture);
-  if (!texture->SafeToRenderFrom()) {
-    DCHECK_NE(0, num_unsafe_textures_);
-    --num_unsafe_textures_;
-  }
-  num_uncleared_mips_ -= texture->num_uncleared_mips();
-  DCHECK_GE(num_uncleared_mips_, 0);
-  texture->SetLevelCleared(target, level, cleared);
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
+  DCHECK(ref);
+  ref->texture()->SetLevelCleared(target, level, cleared);
 }
 
 bool TextureManager::ClearRenderableLevels(
-    GLES2Decoder* decoder,Texture* texture) {
-  DCHECK(texture);
-  if (texture->SafeToRenderFrom()) {
-    return true;
-  }
-  DCHECK_NE(0, num_unsafe_textures_);
-  --num_unsafe_textures_;
-  num_uncleared_mips_ -= texture->num_uncleared_mips();
-  DCHECK_GE(num_uncleared_mips_, 0);
-  bool result = texture->ClearRenderableLevels(decoder);
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
-  return result;
+    GLES2Decoder* decoder, TextureRef* ref) {
+  DCHECK(ref);
+  return ref->texture()->ClearRenderableLevels(decoder);
 }
 
 bool TextureManager::ClearTextureLevel(
-    GLES2Decoder* decoder,Texture* texture,
+    GLES2Decoder* decoder, TextureRef* ref,
     GLenum target, GLint level) {
-  DCHECK(texture);
+  DCHECK(ref);
+  Texture* texture = ref->texture();
   if (texture->num_uncleared_mips() == 0) {
     return true;
   }
-  num_uncleared_mips_ -= texture->num_uncleared_mips();
-  DCHECK_GE(num_uncleared_mips_, 0);
-  if (!texture->SafeToRenderFrom()) {
-    DCHECK_NE(0, num_unsafe_textures_);
-    --num_unsafe_textures_;
-  }
   bool result = texture->ClearLevel(decoder, target, level);
   texture->UpdateCleared();
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
   return result;
 }
 
 void TextureManager::SetLevelInfo(
-    Texture* texture,
+    TextureRef* ref,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
-  DCHECK(texture);
-  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();
-  DCHECK_GE(num_uncleared_mips_, 0);
+  DCHECK(ref);
+  Texture* texture = ref->texture();
 
-  GetMemTracker(texture->pool_)->TrackMemFree(texture->estimated_size());
+  texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
   texture->SetLevelInfo(
       feature_info_, target, level, internal_format, width, height, depth,
       border, format, type, cleared);
-  GetMemTracker(texture->pool_)->TrackMemAlloc(texture->estimated_size());
-
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
+  texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
 }
 
-TextureDefinition* TextureManager::Save(Texture* texture) {
+TextureDefinition* TextureManager::Save(TextureRef* ref) {
+  DCHECK(ref);
+  Texture* texture = ref->texture();
   DCHECK(texture->owned_);
 
   if (texture->IsAttachedToFramebuffer())
     return NULL;
 
   TextureDefinition::LevelInfos level_infos(texture->level_infos_.size());
   for (size_t face = 0; face < level_infos.size(); ++face) {
     GLenum target =
         texture->target() == GL_TEXTURE_CUBE_MAP ? FaceIndexToGLTarget(face)
                                                  : texture->target();
     for (GLint level = 0; level <= texture->max_level_set_; ++level) {
       const Texture::LevelInfo& level_info =
           texture->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,
                                        level_info.cleared));
 
-      SetLevelInfo(texture,
+      SetLevelInfo(ref,
                    target,
                    level,
                    GL_RGBA,
                    0,
                    0,
                    0,
                    0,
                    GL_RGBA,
                    GL_UNSIGNED_BYTE,
                    true);
@@ skipping 18 matching lines @@
                                texture->wrap_t(),
                                texture->usage(),
                                immutable,
                                stream_texture,
                                level_infos);
 }
 
 bool TextureManager::Restore(
     const char* function_name,
     GLES2Decoder* decoder,
-    Texture* texture,
+    TextureRef* ref,
     TextureDefinition* definition) {
+  DCHECK(ref);
+  Texture* texture = ref->texture();
   DCHECK(texture->owned_);
 
   scoped_ptr<TextureDefinition> scoped_definition(definition);
 
   if (texture->IsAttachedToFramebuffer())
     return false;
 
   if (texture->target() != definition->target())
     return false;
 
   if (texture->level_infos_.size() < definition->level_infos().size())
     return false;
 
   if (texture->level_infos_[0].size() < definition->level_infos()[0].size())
     return false;
 
   for (size_t face = 0; face < definition->level_infos().size(); ++face) {
     GLenum target =
         texture->target() == GL_TEXTURE_CUBE_MAP ? FaceIndexToGLTarget(face)
                                                  : texture->target();
     GLint new_max_level = definition->level_infos()[face].size() - 1;
     for (GLint level = 0;
          level <= std::max(texture->max_level_set_, new_max_level);
          ++level) {
       const TextureDefinition::LevelInfo& level_info =
           level <= new_max_level ? definition->level_infos()[face][level]
                                  : TextureDefinition::LevelInfo();
-      SetLevelInfo(texture,
+      SetLevelInfo(ref,
                    target,
                    level,
                    level_info.internal_format,
                    level_info.width,
                    level_info.height,
                    level_info.depth,
                    level_info.border,
                    level_info.format,
                    level_info.type,
                    level_info.cleared);
     }
   }
 
   GLuint old_service_id = texture->service_id();
   glDeleteTextures(1, &old_service_id);
   texture->SetServiceId(definition->ReleaseServiceId());
   glBindTexture(texture->target(), texture->service_id());
   texture->SetImmutable(definition->immutable());
   texture->SetStreamTexture(definition->stream_texture());
-
   ErrorState* error_state = decoder->GetErrorState();
-  SetParameter(function_name, error_state, texture, GL_TEXTURE_MIN_FILTER,
+  SetParameter(function_name, error_state, ref, GL_TEXTURE_MIN_FILTER,
                definition->min_filter());
-  SetParameter(function_name, error_state, texture, GL_TEXTURE_MAG_FILTER,
+  SetParameter(function_name, error_state, ref, GL_TEXTURE_MAG_FILTER,
                definition->mag_filter());
-  SetParameter(function_name, error_state, texture, GL_TEXTURE_WRAP_S,
+  SetParameter(function_name, error_state, ref, GL_TEXTURE_WRAP_S,
                definition->wrap_s());
-  SetParameter(function_name, error_state, texture, GL_TEXTURE_WRAP_T,
+  SetParameter(function_name, error_state, ref, GL_TEXTURE_WRAP_T,
                definition->wrap_t());
   if (feature_info_->validators()->texture_parameter.IsValid(
       GL_TEXTURE_USAGE_ANGLE)) {
-    SetParameter(function_name, error_state, texture, GL_TEXTURE_USAGE_ANGLE,
+    SetParameter(function_name, error_state, ref, GL_TEXTURE_USAGE_ANGLE,
                  definition->usage());
   }
 
   return true;
 }
 
 void TextureManager::SetParameter(
     const char* function_name, ErrorState* error_state,
-    Texture* texture, GLenum pname, GLint param) {
+    TextureRef* ref, GLenum pname, GLint param) {
   DCHECK(error_state);
-  DCHECK(texture);
-  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_;
-  }
+  DCHECK(ref);
+  Texture* texture = ref->texture();
   GLenum result = texture->SetParameter(feature_info_, pname, param);
   if (result != GL_NO_ERROR) {
     if (result == GL_INVALID_ENUM) {
       ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
           error_state, function_name, param, "param");
     } else {
       ERRORSTATE_SET_GL_ERROR_INVALID_PARAM(
           error_state, result, function_name, pname, static_cast<GLint>(param));
     }
   } else {
     // Texture tracking pools exist only for the command decoder, so
     // do not pass them on to the native GL implementation.
     if (pname != GL_TEXTURE_POOL_CHROMIUM) {
       glTexParameteri(texture->target(), pname, param);
     }
   }
-
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
 }
 
-bool TextureManager::MarkMipmapsGenerated(Texture* texture) {
-  DCHECK(texture);
-  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();
-  DCHECK_GE(num_uncleared_mips_, 0);
-  GetMemTracker(texture->pool_)->TrackMemFree(texture->estimated_size());
+bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
+  DCHECK(ref);
+  Texture* texture = ref->texture();
+  texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
   bool result = texture->MarkMipmapsGenerated(feature_info_);
-  GetMemTracker(texture->pool_)->TrackMemAlloc(texture->estimated_size());
-
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
+  texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
   return result;
 }
 
-Texture* TextureManager::CreateTexture(
+TextureRef* TextureManager::CreateTexture(
     GLuint client_id, GLuint service_id) {
   DCHECK_NE(0u, service_id);
-  scoped_refptr<Texture> texture(new Texture(this, service_id));
+  scoped_refptr<TextureRef> ref(TextureRef::Create(this, service_id));
   std::pair<TextureMap::iterator, bool> result =
-      textures_.insert(std::make_pair(client_id, texture));
+      textures_.insert(std::make_pair(client_id, ref));
   DCHECK(result.second);
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
-  num_uncleared_mips_ += texture->num_uncleared_mips();
-  return texture.get();
+  return ref.get();
 }
 
-Texture* TextureManager::GetTexture(
+TextureRef* TextureManager::GetTexture(
     GLuint client_id) const {
   TextureMap::const_iterator it = textures_.find(client_id);
   return it != textures_.end() ? it->second : NULL;
 }
 
 void TextureManager::RemoveTexture(GLuint client_id) {
   TextureMap::iterator it = textures_.find(client_id);
   if (it != textures_.end()) {
-    Texture* texture = it->second;
-    texture->MarkAsDeleted();
     textures_.erase(it);
   }
 }
 
-void TextureManager::StartTracking(Texture* /* texture */) {
+void TextureManager::StartTracking(TextureRef* ref) {
+  Texture* texture = ref->texture();
   ++texture_count_;
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->SafeToRenderFrom()) {
+    DCHECK_NE(0, num_unsafe_textures_);
+    ++num_unsafe_textures_;
+  }
+  if (!texture->CanRender(feature_info_))
+    ++num_unrenderable_textures_;
 }
 
-void TextureManager::StopTracking(Texture* texture) {
+void TextureManager::StopTracking(TextureRef* ref) {
+  Texture* texture = ref->texture();
   --texture_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();
   DCHECK_GE(num_uncleared_mips_, 0);
-  GetMemTracker(texture->pool_)->TrackMemFree(texture->estimated_size());
 }
 
 MemoryTypeTracker* TextureManager::GetMemTracker(GLenum tracking_pool) {
   switch(tracking_pool) {
     case GL_TEXTURE_POOL_MANAGED_CHROMIUM:
       return memory_tracker_managed_.get();
       break;
     case GL_TEXTURE_POOL_UNMANAGED_CHROMIUM:
       return memory_tracker_unmanaged_.get();
       break;
     default:
       break;
   }
   NOTREACHED();
   return NULL;
 }
 
 bool TextureManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (TextureMap::const_iterator it = textures_.begin();
        it != textures_.end(); ++it) {
-    if (it->second->service_id() == service_id) {
+    if (it->second->texture()->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   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(
-    Texture* texture,
+    TextureRef* ref,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
-  DCHECK(texture);
-  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_;
-  }
-  texture->SetLevelImage(feature_info_, target, level, image);
-  if (!texture->CanRender(feature_info_)) {
-    ++num_unrenderable_textures_;
-  }
-  if (!texture->SafeToRenderFrom()) {
-    ++num_unsafe_textures_;
-  }
+  DCHECK(ref);
+  ref->texture()->SetLevelImage(feature_info_, target, level, image);
 }
 
 void TextureManager::AddToSignature(
-    Texture* texture,
+    TextureRef* ref,
     GLenum target,
     GLint level,
     std::string* signature) const {
-  texture->AddToSignature(feature_info_.get(), target, level, signature);
+  ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
+}
+
+void TextureManager::UpdateSafeToRenderFrom(int delta) {
+  num_unsafe_textures_ += delta;
+  DCHECK_GE(num_unsafe_textures_, 0);
+}
+
+void TextureManager::UpdateUnclearedMips(int delta) {
+  num_uncleared_mips_ += delta;
+  DCHECK_GE(num_uncleared_mips_, 0);
+}
+
+void TextureManager::UpdateCanRenderCondition(
+    Texture::CanRenderCondition old_condition,
+    Texture::CanRenderCondition new_condition) {
+  if (old_condition == Texture::CAN_RENDER_NEVER ||
+      (old_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
+       !feature_info_->feature_flags().npot_ok)) {
+    DCHECK_GT(num_unrenderable_textures_, 0);
+    --num_unrenderable_textures_;
+  }
+  if (new_condition == Texture::CAN_RENDER_NEVER ||
+      (new_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
+       !feature_info_->feature_flags().npot_ok))
+    ++num_unrenderable_textures_;
+}
+
+void TextureManager::IncFramebufferStateChangeCount() {
+  if (framebuffer_manager_)
+    framebuffer_manager_->IncFramebufferStateChangeCount();
+
 }
 
 }  // namespace gles2
 }  // namespace gpu