gpu: Use a rectangle to keep track of the cleared area of each texture level.

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 263 matching lines @@
     destruction_observers_[i]->OnTextureManagerDestroying(this);
 
   DCHECK(textures_.empty());
 
   // If this triggers, that means something is keeping a reference to
   // a Texture belonging to this.
   CHECK_EQ(texture_count_, 0u);
 
   DCHECK_EQ(0, num_unrenderable_textures_);
   DCHECK_EQ(0, num_unsafe_textures_);
-  DCHECK_EQ(0, num_uncleared_mips_);
   DCHECK_EQ(0, num_images_);
 }
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
   textures_.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());
 }
 
 Texture::Texture(GLuint service_id)
     : mailbox_manager_(NULL),
       memory_tracking_ref_(NULL),
       service_id_(service_id),
       cleared_(true),
-      num_uncleared_mips_(0),
       num_npot_faces_(0),
       target_(0),
       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
       mag_filter_(GL_LINEAR),
       wrap_r_(GL_REPEAT),
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       compare_func_(GL_LEQUAL),
@@ skipping 53 matching lines @@
     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),
+    : target(0),
       level(-1),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
       type(0),
       estimated_size(0) {
 }
 
 Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
-    : cleared(rhs.cleared),
+    : cleared_rect(rhs.cleared_rect),
       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),
@@ skipping 126 matching lines @@
     GLsizei height = level0_info.height;
     GLsizei depth = level0_info.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                GLES2Util::IndexToGLFaceTarget(ii);
 
     const GLsizei num_mips = face_info.num_mip_levels;
     for (GLsizei 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,
-                   level0_info.internal_format,
-                   width,
-                   height,
-                   depth,
-                   level0_info.border,
-                   level0_info.format,
-                   level0_info.type,
-                   true);
+      SetLevelInfo(feature_info, target, level, level0_info.internal_format,
+                   width, height, depth, level0_info.border, level0_info.format,
+                   level0_info.type, gfx::Rect(width, height));
     }
   }
 
   return true;
 }
 
 void Texture::SetTarget(
     const FeatureInfo* feature_info, GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
@@ skipping 94 matching lines @@
     complete &= (width == mip_width &&
                  height == mip_height &&
                  depth == mip_depth &&
                  internal_format == level0_face.internal_format &&
                  format == level0_face.format &&
                  type == level0_face.type);
   }
   return complete;
 }
 
-void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
+void Texture::SetLevelClearedRect(GLenum target,
+                                  GLint level,
+                                  const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
-  UpdateMipCleared(&info, cleared);
-  UpdateCleared();
+  info.cleared_rect = cleared_rect;

[piman, 2015/05/27 20:50:17]

nit: could we have a DCHECK that cleared_rect only grows?

[reveman, 2015/06/03 22:40:04]

Done. By adding DCHECKs to the caller as we can't always assume that the rect is
growing when setting the LevelInfo::cleared_rect in latest patch.

+  UpdateSafeToRenderFrom();
 }
 
-void Texture::UpdateCleared() {
-  if (face_infos_.empty()) {
-    return;
+void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
+  DCHECK_GE(level, 0);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
+  DCHECK_LT(static_cast<size_t>(level),
+            face_infos_[face_index].level_infos.size());
+  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  info.cleared_rect =
+      cleared ? gfx::Rect(info.width, info.height) : gfx::Rect();
+  UpdateSafeToRenderFrom();
+}
+
+void Texture::UpdateSafeToRenderFrom() {
+  bool cleared = true;
+  for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
+    for (size_t jj = 0; jj < face_infos_[ii].level_infos.size(); ++jj) {
+      const Texture::LevelInfo& info = face_infos_[ii].level_infos[jj];
+      if (!info.cleared_rect.Contains(gfx::Rect(info.width, info.height))) {
+        cleared = false;
+        break;
+      }
+    }
   }

[piman, 2015/05/27 20:50:17]

I worry about the extra tracking cost here. This is called in many places, among
others TexParameteri which we do at run-time to change filtering mode even
though in this case it wouldn't impact cleared state.
level_infos is always the size of max_levels_ (i.e. typically 12-14), and
Rect::Contains is really non-trivial.

Given that this is just initialization state, I think I'd prefer keeping the
existing incremental tracking. We can keep the bulk of the existing logic, it's
just that we need to update when the cleared_rect changes from non-complete to
complete (i.e. you can simply change LevelInfo::cleared to a bool
LevelInfo::cleared() const { return cleared_rect.Contains(gfx::Rect(width,
height); }

[reveman, 2015/06/03 22:40:04]

Done. However, this is a bit more complicated than simply changing
LevelInfo::cleared into a function as LevelInfo::width/height affects this
state. Latest patch handles that by requiring that all state that affects
whether the level is cleared to be passed to UpdateMipCleared.

 
-  const bool cleared = (num_uncleared_mips_ == 0);
-
-  // If texture is uncleared and is attached to a framebuffer,
-  // that framebuffer must be marked possibly incomplete.
-  if (!cleared && IsAttachedToFramebuffer()) {
-    IncAllFramebufferStateChangeCount();
-  }
-
-  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);
+  // If texture is uncleared and is attached to a framebuffer,
+  // that framebuffer must be marked possibly incomplete.
+  if (!cleared && IsAttachedToFramebuffer())
+    IncAllFramebufferStateChangeCount();
 }
 
 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;
@@ skipping 20 matching lines @@
   int delta = has_images ? +1 : -1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateNumImages(delta);
 }
 
 void Texture::IncAllFramebufferStateChangeCount() {
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->IncFramebufferStateChangeCount();
 }
 
-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) {
+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,
+                           const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
   Texture::LevelInfo& info =
@@ skipping 37 matching lines @@
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
-  UpdateMipCleared(&info, cleared);
+  info.cleared_rect = cleared_rect;
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
-  UpdateCleared();
+  UpdateSafeToRenderFrom();
   UpdateCanRenderCondition();
   UpdateHasImages();
   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(
@@ skipping 156 matching lines @@
       if (!feature_info->validators()->texture_usage.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       usage_ = param;
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   Update(feature_info);
-  UpdateCleared();
+  UpdateSafeToRenderFrom();
   UpdateCanRenderCondition();
   return GL_NO_ERROR;
 }
 
 GLenum Texture::SetParameterf(
     const FeatureInfo* feature_info, GLenum pname, GLfloat param) {
   switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_MAG_FILTER:
     case GL_TEXTURE_POOL_CHROMIUM:
@@ skipping 121 matching lines @@
     const Texture::FaceInfo& face_info = face_infos_[ii];
     for (GLint jj = 0; jj < face_info.num_mip_levels; ++jj) {
       const Texture::LevelInfo& info = face_info.level_infos[jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
   }
-  UpdateSafeToRenderFrom(true);
+  UpdateSafeToRenderFrom();
   return true;
 }
 
+gfx::Rect Texture::GetLevelClearedRect(GLenum target, GLint level) const {
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  if (face_index >= face_infos_.size() ||
+      level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
+    return gfx::Rect();
+  }
+
+  const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+
+  return info.cleared_rect;
+}
+
 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
 
   const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
 
-  return info.cleared;
+  return info.cleared_rect.Contains(gfx::Rect(info.width, info.height));
 }
 
 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
   if (texture_max_anisotropy_initialized_)
     return;
   texture_max_anisotropy_initialized_ = true;
   GLfloat params[] = { 1.0f };
   glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
 }
 
 bool Texture::ClearLevel(
     GLES2Decoder* decoder, GLenum target, GLint level) {
   DCHECK(decoder);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
 
   Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
 
   DCHECK(target == info.target);
 
   if (info.target == 0 ||
-      info.cleared ||
-      info.width == 0 ||
-      info.height == 0 ||
-      info.depth == 0) {
+      info.cleared_rect.Contains(gfx::Rect(info.width, info.height)) ||
+      info.width == 0 || info.height == 0 || info.depth == 0) {
     return true;
   }
 
-  // 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.
-  bool cleared = decoder->ClearLevel(
-      this, info.target, info.level, info.internal_format, info.format,
-      info.type, info.width, info.height, immutable_);
-  UpdateMipCleared(&info, cleared);
-  return info.cleared;
+  // Clear all remaining sub regions.
+  const int x[] = {
+      0, info.cleared_rect.x(), info.cleared_rect.right(), info.width};
+  const int y[] = {
+      0, info.cleared_rect.y(), info.cleared_rect.bottom(), info.height};
+
+  for (size_t j = 0; j < 3; ++j) {
+    for (size_t i = 0; i < 3; ++i) {
+      // Center of nine patch is already cleared.
+      if (j == 1 && i == 1)
+        continue;
+
+      gfx::Rect rect(x[i], y[j], x[i + 1] - x[i], y[j + 1] - y[j]);
+      if (rect.IsEmpty())
+        continue;
+
+      // 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.
+      bool cleared = decoder->ClearLevel(this, info.target, info.level,
+                                         info.format, info.type, rect.x(),
+                                         rect.y(), rect.width(), rect.height());
+      if (!cleared)
+        return false;
+    }
+  }
+
+  info.cleared_rect = gfx::Rect(info.width, info.height);
+  return true;
 }
 
 void Texture::SetLevelImage(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
@@ skipping 89 matching lines @@
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       max_3d_levels_(ComputeMipMapCount(GL_TEXTURE_3D,
                                         // Same as GL_TEXTURE_2D_ARRAY
                                         max_3d_texture_size,
                                         max_3d_texture_size,
                                         max_3d_texture_size)),
       use_default_textures_(use_default_textures),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
-      num_uncleared_mips_(0),
       num_images_(0),
       texture_count_(0),
       have_context_(true) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
 }
 
 bool TextureManager::Initialize() {
   // TODO(gman): The default textures have to be real textures, not the 0
@@ skipping 48 matching lines @@
     }
   }
   glBindTexture(target, 0);
 
   scoped_refptr<TextureRef> default_texture;
   if (use_default_textures_) {
     default_texture = TextureRef::Create(this, 0, ids[1]);
     SetTarget(default_texture.get(), target);
     if (needs_faces) {
       for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
-        SetLevelInfo(default_texture.get(),
-                     GLES2Util::IndexToGLFaceTarget(ii),
-                     0,
-                     GL_RGBA,
-                     1,
-                     1,
-                     1,
-                     0,
-                     GL_RGBA,
-                     GL_UNSIGNED_BYTE,
-                     true);
+        SetLevelInfo(default_texture.get(), GLES2Util::IndexToGLFaceTarget(ii),
+                     0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                     gfx::Rect(1, 1));
       }
     } else {
       if (needs_initialization) {
-        SetLevelInfo(default_texture.get(),
-                     GL_TEXTURE_2D,
-                     0,
-                     GL_RGBA,
-                     1,
-                     1,
-                     1,
-                     0,
-                     GL_RGBA,
-                     GL_UNSIGNED_BYTE,
-                     true);
+        SetLevelInfo(default_texture.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1,
+                     0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(1, 1));
       } else {
-        SetLevelInfo(default_texture.get(),
-                     GL_TEXTURE_EXTERNAL_OES,
-                     0,
-                     GL_RGBA,
-                     1,
-                     1,
-                     1,
-                     0,
-                     GL_RGBA,
-                     GL_UNSIGNED_BYTE,
-                     true);
+        SetLevelInfo(default_texture.get(), GL_TEXTURE_EXTERNAL_OES, 0, GL_RGBA,
+                     1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(1, 1));
       }
     }
   }
 
   *black_texture = ids[0];
   return default_texture;
 }
 
 bool TextureManager::ValidForTarget(
     GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
@@ skipping 13 matching lines @@
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   DCHECK(ref);
   ref->texture()
       ->SetTarget(feature_info_.get(), target, MaxLevelsForTarget(target));
 }
 
+void TextureManager::SetLevelClearedRect(TextureRef* ref,
+                                         GLenum target,
+                                         GLint level,
+                                         const gfx::Rect& cleared_rect) {
+  DCHECK(ref);
+  ref->texture()->SetLevelClearedRect(target, level, cleared_rect);
+}
+
 void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
   DCHECK(ref);
   ref->texture()->SetLevelCleared(target, level, cleared);
 }
 
 bool TextureManager::ClearRenderableLevels(
     GLES2Decoder* decoder, TextureRef* ref) {
   DCHECK(ref);
   return ref->texture()->ClearRenderableLevels(decoder);
 }
 
 bool TextureManager::ClearTextureLevel(
     GLES2Decoder* decoder, TextureRef* ref,
     GLenum target, GLint level) {
   DCHECK(ref);
   Texture* texture = ref->texture();
-  if (texture->num_uncleared_mips() == 0) {
+  if (texture->SafeToRenderFrom()) {
     return true;
   }
   bool result = texture->ClearLevel(decoder, target, level);
-  texture->UpdateCleared();
+  texture->UpdateSafeToRenderFrom();
   return result;
 }
 
-void TextureManager::SetLevelInfo(
-    TextureRef* ref,
-    GLenum target,
-    GLint level,
-    GLenum internal_format,
-    GLsizei width,
-    GLsizei height,
-    GLsizei depth,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    bool cleared) {
+void TextureManager::SetLevelInfo(TextureRef* ref,
+                                  GLenum target,
+                                  GLint level,
+                                  GLenum internal_format,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth,
+                                  GLint border,
+                                  GLenum format,
+                                  GLenum type,
+                                  const gfx::Rect& cleared_rect) {
+  DCHECK(gfx::Rect(width, height).Contains(cleared_rect));
   DCHECK(ref);
   Texture* texture = ref->texture();
 
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
-  texture->SetLevelInfo(feature_info_.get(),
-                        target,
-                        level,
-                        internal_format,
-                        width,
-                        height,
-                        depth,
-                        border,
-                        format,
-                        type,
-                        cleared);
+  texture->SetLevelInfo(feature_info_.get(), target, level, internal_format,
+                        width, height, depth, border, format, type,
+                        cleared_rect);
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
 }
 
 Texture* TextureManager::Produce(TextureRef* ref) {
   DCHECK(ref);
   return ref->texture();
 }
 
 TextureRef* TextureManager::Consume(
     GLuint client_id,
@@ skipping 83 matching lines @@
   TextureMap::iterator it = textures_.find(client_id);
   if (it != textures_.end()) {
     it->second->reset_client_id();
     textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(TextureRef* ref) {
   Texture* texture = ref->texture();
   ++texture_count_;
-  num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->SafeToRenderFrom())
     ++num_unsafe_textures_;
   if (!texture->CanRender(feature_info_.get()))
     ++num_unrenderable_textures_;
   if (texture->HasImages())
     ++num_images_;
 }
 
 void TextureManager::StopTracking(TextureRef* ref) {
   if (ref->num_observers()) {
@@ skipping 11 matching lines @@
     --num_images_;
   }
   if (!texture->CanRender(feature_info_.get())) {
     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);
 }
 
 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;
@@ skipping 47 matching lines @@
     GLint level,
     std::string* signature) const {
   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 ||
@@ skipping 214 matching lines @@
   GLenum tex_format = 0;
   bool level_is_same =
       texture->GetLevelSize(
           args.target, args.level, &tex_width, &tex_height, nullptr) &&
       texture->GetLevelType(args.target, args.level, &tex_type, &tex_format) &&
       args.width == tex_width && args.height == tex_height &&
       args.type == tex_type && args.format == tex_format;
 
   if (level_is_same && !args.pixels) {
     // Just set the level texture but mark the texture as uncleared.
-    SetLevelInfo(
-        texture_ref,
-        args.target, args.level, args.internal_format, args.width, args.height,
-        1, args.border, args.format, args.type, false);
+    SetLevelInfo(texture_ref, args.target, args.level, args.internal_format,
+                 args.width, args.height, 1, args.border, args.format,
+                 args.type, gfx::Rect());
     texture_state->tex_image_2d_failed = false;
     return;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state->clear_state_dirty = true;
   }
 
   if (texture_state->texsubimage2d_faster_than_teximage2d &&
       level_is_same && args.pixels) {
@@ skipping 10 matching lines @@
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glTexImage2D");
   {
     ScopedTextureUploadTimer timer(texture_state);
     glTexImage2D(
         args.target, args.level, args.internal_format, args.width, args.height,
         args.border, AdjustTexFormat(args.format), args.type, args.pixels);
   }
   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glTexImage2D");
   if (error == GL_NO_ERROR) {
     SetLevelInfo(
-        texture_ref,
-        args.target, args.level, args.internal_format, args.width, args.height,
-        1, args.border, args.format, args.type, args.pixels != NULL);
+        texture_ref, args.target, args.level, args.internal_format, args.width,
+        args.height, 1, args.border, args.format, args.type,
+        args.pixels != NULL ? gfx::Rect(args.width, args.height) : gfx::Rect());
     texture_state->tex_image_2d_failed = false;
   }
 }
 
 ScopedTextureUploadTimer::ScopedTextureUploadTimer(
     DecoderTextureState* texture_state)
     : texture_state_(texture_state),
       begin_time_(base::TimeTicks::Now()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::Now() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu