Defer clearing textures and renderbuffers

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2011 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 "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 100 matching lines @@
 bool TextureManager::TextureInfo::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];
     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);
     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_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
-                                              FaceIndexToGLTarget(ii),
+                   target,
                    level,
                    info1.internal_format,
                    width,
                    height,
                    depth,
                    info1.border,
                    info1.format,
-                   info1.type);
+                   info1.type,
+                   true);
     }
   }
+
   return true;
 }
 
 void TextureManager::TextureInfo::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) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 }
 
 bool TextureManager::TextureInfo::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       level_infos_.empty() || IsDeleted() ||
       target_ == GL_TEXTURE_EXTERNAL_OES) {
     return false;
   }
   const TextureInfo::LevelInfo& first = level_infos_[0][0];
   // 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.valid) ||
+    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)) {
         return false;
     }
   }
   return true;
 }
 
+void TextureManager::TextureInfo::SetLevelCleared(GLenum target, GLint level) {
+  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 =
+      level_infos_[GLTargetToFaceIndex(target)][level];
+  if (!info.cleared) {
+    DCHECK_NE(0, num_uncleared_mips_);
+    --num_uncleared_mips_;
+  }
+  info.cleared = true;
+  UpdateCleared();
+}
+
+void TextureManager::TextureInfo::UpdateCleared() {
+  if (level_infos_.empty()) {
+    return;
+  }
+
+  const TextureInfo::LevelInfo& first_face = level_infos_[0][0];
+  int levels_needed = 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];
+      if (info.width > 0 && info.height > 0 && info.depth > 0 &&
+          !info.cleared) {
+        cleared_ = false;
+        return;
+      }
+    }
+  }
+}
+
 void TextureManager::TextureInfo::SetLevelInfo(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
-    GLenum type) {
+    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 =
       level_infos_[GLTargetToFaceIndex(target)][level];
-  info.valid = true;
+  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;
+  if (!info.cleared) {
+    DCHECK_NE(0, num_uncleared_mips_);
+    --num_uncleared_mips_;
+  }
+  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(
     GLint face,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
@@ skipping 17 matching lines @@
 }
 
 bool TextureManager::TextureInfo::GetLevelSize(
     GLint face, GLint level, GLsizei* width, GLsizei* height) const {
   DCHECK(width);
   DCHECK(height);
   size_t face_index = GLTargetToFaceIndex(face);
   if (!IsDeleted() && level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
-    if (info.valid) {
+    if (info.target != 0) {
       *width = info.width;
       *height = info.height;
       return true;
     }
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::GetLevelType(
     GLint face, GLint level, GLenum* type, GLenum* internal_format) const {
   DCHECK(type);
   DCHECK(internal_format);
   size_t face_index = GLTargetToFaceIndex(face);
   if (!IsDeleted() && level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
-    if (info.valid) {
+    if (info.target != 0) {
       *type = info.type;
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::SetParameter(
     const FeatureInfo* feature_info, GLenum pname, GLint param) {
@@ skipping 34 matching lines @@
       wrap_t_ = param;
       break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       // Nothing to do for this case at the moment.
       break;
     default:
       NOTREACHED();
       return false;
   }
   Update(feature_info);
+  UpdateCleared();
   return true;
 }
 
 void TextureManager::TextureInfo::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];
     if (GLES2Util::IsNPOT(info.width) ||
         GLES2Util::IsNPOT(info.height) ||
         GLES2Util::IsNPOT(info.depth)) {
       npot_ = true;
       break;
     }
   }
 
@@ skipping 16 matching lines @@
   } 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];
-    if (!level0.valid ||
+    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];
-      if (!info.valid ||
+      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) {
+  DCHECK(decoder);
+  if (SafeToRenderFrom()) {
+    return true;
+  }
+
+  const TextureInfo::LevelInfo& first_face = level_infos_[0][0];
+  int levels_needed = 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];
+      if (info.target != 0) {
+        if (!ClearLevel(decoder, info.target, jj)) {
+          return false;
+        }
+      }
+    }
+  }
+  cleared_ = true;
+  return true;
+}
+
+bool TextureManager::TextureInfo::IsLevelCleared(GLenum target, GLint level) {
+  size_t face_index = GLTargetToFaceIndex(target);
+  if (IsDeleted() ||
+      face_index >= level_infos_.size() ||
+      level >= static_cast<GLint>(level_infos_[face_index].size())) {
+    return true;
+  }
+
+  TextureInfo::LevelInfo& info = level_infos_[face_index][level];
+
+  return info.cleared;
+}
+
+bool TextureManager::TextureInfo::ClearLevel(
+    GLES2Decoder* decoder, GLenum target, GLint level) {
+  DCHECK(decoder);
+  size_t face_index = GLTargetToFaceIndex(target);
+  if (IsDeleted() ||
+      face_index >= level_infos_.size() ||
+      level >= static_cast<GLint>(level_infos_[face_index].size())) {
+    return true;
+  }
+
+  TextureInfo::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);
+  if (!info.cleared) {
+    ++num_uncleared_mips_;
+  }
+  return info.cleared;
+}
+
 TextureManager::TextureManager(
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
     : 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),
+      num_uncleared_mips_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0) {
 }
 
 bool TextureManager::Initialize(const FeatureInfo* feature_info) {
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
 
   // Make default textures and texture for replacing non-renderable textures.
   GLuint ids[4];
   glGenTextures(arraysize(ids), ids);
   static uint8 black[] = {0, 0, 0, 255};
   for (int ii = 0; ii < 2; ++ii) {
     glBindTexture(GL_TEXTURE_2D, ids[ii]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
                  GL_UNSIGNED_BYTE, black);
     glBindTexture(GL_TEXTURE_CUBE_MAP, ids[2 + ii]);
     for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
       glTexImage2D(GLES2Util::IndexToGLFaceTarget(ii), 0, GL_RGBA, 1, 1, 0,
                    GL_RGBA, GL_UNSIGNED_BYTE, black);
     }
   }
   glBindTexture(GL_TEXTURE_2D, 0);
   glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
 
+  // Since we are manually setting up these textures
+  // we need to manually manipulate some of the their bookkeeping.
+  num_unrenderable_textures_ += 2;
   FeatureInfo temp_feature_info;
   default_texture_2d_ = TextureInfo::Ref(new TextureInfo(ids[1]));
   SetInfoTarget(feature_info, default_texture_2d_, GL_TEXTURE_2D);
-  default_texture_2d_->SetLevelInfo(&temp_feature_info,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE);
+  SetLevelInfo(&temp_feature_info, default_texture_2d_,
+      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   default_texture_cube_map_ = TextureInfo::Ref(new TextureInfo(ids[3]));
   SetInfoTarget(feature_info, default_texture_cube_map_, GL_TEXTURE_CUBE_MAP);
   for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
-    default_texture_cube_map_->SetLevelInfo(
-      &temp_feature_info, GLES2Util::IndexToGLFaceTarget(ii),
-      0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE);
+    SetLevelInfo(
+        &temp_feature_info, default_texture_cube_map_,
+        GLES2Util::IndexToGLFaceTarget(ii),
+        0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   }
 
   black_2d_texture_id_ = ids[0];
   black_cube_texture_id_ = ids[2];
 
   if (feature_info->feature_flags().oes_egl_image_external) {
+    // Since we are manually setting up these textures
+    // we need to manually manipulate some of the their bookkeeping.
+    num_unrenderable_textures_ += 1;
     GLuint external_ids[2];
     glGenTextures(arraysize(external_ids), external_ids);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
     default_texture_external_oes_ = TextureInfo::Ref(
         new TextureInfo(external_ids[0]));
     SetInfoTarget(feature_info,
                   default_texture_external_oes_,
                   GL_TEXTURE_EXTERNAL_OES);
     default_texture_external_oes_->SetLevelInfo(
         &temp_feature_info, GL_TEXTURE_EXTERNAL_OES, 0,
-        GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE);
+        GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
 
     // Sampling a texture not associated with any EGLImage sibling will return
     // black values according to the spec.
     black_oes_external_texture_id_ = external_ids[1];
   }
 
   return true;
 }
 
 bool TextureManager::ValidForTarget(
@@ skipping 12 matching lines @@
          (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(
     const FeatureInfo* feature_info,
-    TextureInfo* info, GLenum target) {
+    TextureManager::TextureInfo* 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, GLenum target, GLint level) {
+  DCHECK(info);
+  DCHECK(!info->IsDeleted());
+  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);
+  num_uncleared_mips_ += info->num_uncleared_mips();
+  if (!info->SafeToRenderFrom()) {
+    ++num_unsafe_textures_;
+  }
+}
+
+bool TextureManager::ClearRenderableLevels(
+    GLES2Decoder* decoder,TextureManager::TextureInfo* info) {
+  DCHECK(info);
+  DCHECK(!info->IsDeleted());
+  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,
+    GLenum target, GLint level) {
+  DCHECK(info);
+  DCHECK(!info->IsDeleted());
+  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(
     const FeatureInfo* feature_info,
     TextureManager::TextureInfo* info,
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
-    GLenum type) {
+    GLenum type,
+    bool cleared) {
   DCHECK(info);
   DCHECK(!info->IsDeleted());
   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);
   info->SetLevelInfo(
       feature_info, target, level, internal_format, width, height, depth,
-      border, format, type);
+      border, format, type, cleared);
+  num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info)) {
     ++num_unrenderable_textures_;
   }
+  if (!info->SafeToRenderFrom()) {
+    ++num_unsafe_textures_;
+  }
 }
 
 bool TextureManager::SetParameter(
     const FeatureInfo* feature_info,
     TextureManager::TextureInfo* info, GLenum pname, GLint param) {
   DCHECK(feature_info);
   DCHECK(info);
   DCHECK(!info->IsDeleted());
   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_;
+  }
   bool 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(
     const FeatureInfo* feature_info,
     TextureManager::TextureInfo* info) {
   DCHECK(info);
   DCHECK(!info->IsDeleted());
   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);
   bool result = info->MarkMipmapsGenerated(feature_info);
+  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(
     const FeatureInfo* feature_info,
     GLuint client_id, GLuint service_id) {
   TextureInfo::Ref info(new TextureInfo(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(
     GLuint client_id) {
   TextureInfoMap::iterator it = texture_infos_.find(client_id);
   return it != texture_infos_.end() ? it->second : NULL;
 }
 
 void TextureManager::RemoveTextureInfo(
     const FeatureInfo* feature_info, GLuint client_id) {
   TextureInfoMap::iterator it = texture_infos_.find(client_id);
   if (it != texture_infos_.end()) {
     TextureInfo* info = it->second;
     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);
     info->MarkAsDeleted();
     texture_infos_.erase(it);
   }
 }
 
 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 (TextureInfoMap::const_iterator it = texture_infos_.begin();
        it != texture_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu