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

gpu/command_buffer/service/texture_manager_unittest.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 <utility>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 100 matching lines @@
 const GLint TextureManagerTest::kMaxCubeMapLevels;
 const GLint TextureManagerTest::kMaxExternalLevels;
 #endif
 
 TEST_F(TextureManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
   // Check we can create texture.
   manager_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
   scoped_refptr<TextureRef> texture = manager_->GetTexture(kClient1Id);
   ASSERT_TRUE(texture.get() != NULL);
   EXPECT_EQ(kService1Id, texture->service_id());
   EXPECT_EQ(kClient1Id, texture->client_id());
   EXPECT_EQ(texture->texture(), manager_->GetTextureForServiceId(
       texture->service_id()));
   // Check we get nothing for a non-existent texture.
@@ skipping 368 matching lines @@
               TrackMemoryAllocatedChange(old_size, new_size, pool)) \
       .Times(1).RetiresOnSaturation()
 
 TEST_F(TextureTest, Basic) {
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(0u, texture->target());
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
-  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(texture->IsImmutable());
   EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR),
             texture->min_filter());
   EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture->mag_filter());
   EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_s());
   EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_t());
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
@@ skipping 20 matching lines @@
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_TRUE(texture->IsImmutable());
 }
 
 TEST_F(TextureTest, ZeroSizeCanNotRender) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         1,
-                         1,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(1, 1));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         0,
-                         0,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
 }
 
 TEST_F(TextureTest, EstimatedSize) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   EXPECT_EQ(8u * 4u * 4u, texture_ref_->texture()->estimated_size());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         2,
-                         GL_RGBA,
-                         8,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   EXPECT_EQ(8u * 4u * 4u * 2u, texture_ref_->texture()->estimated_size());
 }
 
 TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         2,
-                         GL_RGBA,
-                         8,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   // Add expectation for texture deletion.
   EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
 }
 
 TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 4));
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged);
   SetParameter(texture_ref_.get(),
                GL_TEXTURE_POOL_CHROMIUM,
                GL_TEXTURE_POOL_MANAGED_CHROMIUM,
                GL_NO_ERROR);
   // Add expectation for texture deletion.
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
 }
 
 TEST_F(TextureTest, POT2D) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to POT
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
-  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set filters to something that will work with a single mip.
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set them back.
   SetParameter(texture_ref_.get(),
                GL_TEXTURE_MIN_FILTER,
                GL_LINEAR_MIPMAP_LINEAR,
                GL_NO_ERROR);
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change a mip.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         3,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged);
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
 }
 
 TEST_F(TextureTest, UnusedMips) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Set level zero to large size.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set level zero to large smaller (levels unused mips)
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set an unused level to some size
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         4,
-                         GL_RGBA,
-                         16,
-                         16,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 4, GL_RGBA, 16, 16,
+                         1, 0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(16, 16));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureTest, NPOT2D) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         5,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
   EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change it to POT.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
   TextureManager manager(NULL,
                          feature_info.get(),
                          kMaxTextureSize,
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
 
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
-  manager.SetLevelInfo(texture_ref,
-      GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0,
+                       GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
   EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref));
   EXPECT_FALSE(manager.CanRender(texture_ref));
   EXPECT_TRUE(manager.HaveUnrenderableTextures());
   EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager.CanRender(texture_ref));
   EXPECT_FALSE(manager.HaveUnrenderableTextures());
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, POTCubeMap) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
   // Check Setting level 0 each face to POT
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
   // Make mips.
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 
   // Change a mip.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
-                         1,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 1,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
-                         3,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 3,
+                         GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         gfx::Rect(4, 4));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
 }
 
 TEST_F(TextureTest, GetLevelSize) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_3D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_3D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         5,
-                         6,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_3D, 1, GL_RGBA, 4, 5, 6,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
   GLsizei width = -1;
   GLsizei height = -1;
   GLsizei depth = -1;
   Texture* texture = texture_ref_->texture();
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_3D, -1, &width, &height, &depth));
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_3D, 1000, &width, &height, &depth));
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_3D, 0, &width, &height, &depth));
   EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_3D, 1, &width, &height, &depth));
   EXPECT_EQ(4, width);
   EXPECT_EQ(5, height);
   EXPECT_EQ(6, depth);
   manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_3D, 1, &width, &height, &depth));
   EXPECT_EQ(4, width);
   EXPECT_EQ(5, height);
   EXPECT_EQ(6, depth);
 }
 
 TEST_F(TextureTest, GetLevelType) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         5,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
   GLenum type = 0;
   GLenum format = 0;
   Texture* texture = texture_ref_->texture();
   EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
   EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
   EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
   manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
 }
 
 TEST_F(TextureTest, ValidForTexture) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         5,
-                         6,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 6,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
   // Check bad face.
   Texture* texture = texture_ref_->texture();
   EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       1, 0, 0, 0, 4, 5, 6, GL_UNSIGNED_BYTE));
   // Check bad level.
   EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 0, 0, 0, 0, 4, 5, 6, GL_UNSIGNED_BYTE));
   // Check bad xoffset.
   EXPECT_FALSE(texture->ValidForTexture(
@@ skipping 47 matching lines @@
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture_ref,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                       GL_RGBA, GL_FLOAT, gfx::Rect(1, 1));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
@@ skipping 10 matching lines @@
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture_ref,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                       GL_RGBA, GL_FLOAT, gfx::Rect(1, 1));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
   TextureManager manager(NULL,
                          feature_info.get(),
                          kMaxTextureSize,
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture_ref,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                       GL_RGBA, GL_HALF_FLOAT_OES, gfx::Rect(1, 1));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
@@ skipping 10 matching lines @@
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture_ref,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                       GL_RGBA, GL_HALF_FLOAT_OES, gfx::Rect(1, 1));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
   TextureManager manager(NULL,
@@ skipping 22 matching lines @@
                          feature_info.get(),
                          kMaxTextureSize,
                          kMaxCubeMapTextureSize,
                          kMaxRectangleTextureSize,
                          kMax3DTextureSize,
                          kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
-  manager.SetLevelInfo(
-      texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
-      GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
+  manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4,
+                       1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, gfx::Rect());
   EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, SafeUnsafe) {
   static const GLuint kClient2Id = 2;
   static const GLuint kService2Id = 12;
   static const GLuint kClient3Id = 3;
   static const GLuint kService3Id = 13;
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
+  EXPECT_FALSE(manager_->HaveUnsafeTextures());
   Texture* texture = texture_ref_->texture();
-  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
 
   manager_->CreateTexture(kClient2Id, kService2Id);
   scoped_refptr<TextureRef> texture_ref2(
       manager_->GetTexture(kClient2Id));
   ASSERT_TRUE(texture_ref2.get() != NULL);
   manager_->SetTarget(texture_ref2.get(), GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
   Texture* texture2 = texture_ref2->texture();
-  EXPECT_EQ(0, texture2->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref2.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  EXPECT_TRUE(texture2->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref2.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(8, 8));
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture2->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref2.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  EXPECT_TRUE(texture2->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref2.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture2->num_uncleared_mips());
+  EXPECT_FALSE(texture2->SafeToRenderFrom());
 
   manager_->CreateTexture(kClient3Id, kService3Id);
   scoped_refptr<TextureRef> texture_ref3(
       manager_->GetTexture(kClient3Id));
   ASSERT_TRUE(texture_ref3.get() != NULL);
   manager_->SetTarget(texture_ref3.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref3.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref3.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
   Texture* texture3 = texture_ref3->texture();
-  EXPECT_EQ(1, texture3->num_uncleared_mips());
+  EXPECT_FALSE(texture3->SafeToRenderFrom());
   manager_->SetLevelCleared(texture_ref2.get(), GL_TEXTURE_2D, 0, true);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture2->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_ref3.get(), GL_TEXTURE_2D, 0, true);
+  EXPECT_TRUE(texture2->SafeToRenderFrom());
+  manager_->SetLevelClearedRect(texture_ref3.get(), GL_TEXTURE_2D, 0,
+                                gfx::Rect(4, 4));
+  EXPECT_TRUE(manager_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture3->SafeToRenderFrom());
+  manager_->SetLevelClearedRect(texture_ref3.get(), GL_TEXTURE_2D, 0,
+                                gfx::Rect(8, 7));
+  EXPECT_TRUE(manager_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture3->SafeToRenderFrom());
+  manager_->SetLevelClearedRect(texture_ref3.get(), GL_TEXTURE_2D, 0,
+                                gfx::Rect(8, 8));
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture3->num_uncleared_mips());
+  EXPECT_TRUE(texture3->SafeToRenderFrom());
 
-  manager_->SetLevelInfo(texture_ref2.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
-  manager_->SetLevelInfo(texture_ref3.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         8,
-                         8,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref2.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+  manager_->SetLevelInfo(texture_ref3.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture2->num_uncleared_mips());
-  EXPECT_EQ(1, texture3->num_uncleared_mips());
+  EXPECT_FALSE(texture2->SafeToRenderFrom());
+  EXPECT_FALSE(texture3->SafeToRenderFrom());
   manager_->RemoveTexture(kClient3Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
   manager_->RemoveTexture(kClient2Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
   texture_ref2 = NULL;
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
       .Times(1)
       .RetiresOnSaturation();
   texture_ref3 = NULL;
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
 }
 
 TEST_F(TextureTest, ClearTexture) {
   EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   Texture* texture = texture_ref_->texture();
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->ClearRenderableLevels(decoder_.get(), texture_ref_.get());
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->ClearTextureLevel(
       decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 0);
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
-  EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   manager_->ClearTextureLevel(
       decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 1);
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_F(TextureTest, UseDeletedTexture) {
   static const GLuint kClient2Id = 2;
   static const GLuint kService2Id = 12;
   // Make the default texture renderable
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         1,
-                         1,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Make a new texture
   manager_->CreateTexture(kClient2Id, kService2Id);
   scoped_refptr<TextureRef> texture_ref(
       manager_->GetTexture(kClient2Id));
   manager_->SetTarget(texture_ref.get(), GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->CanRender(texture_ref.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Remove it.
   manager_->RemoveTexture(kClient2Id);
   EXPECT_FALSE(manager_->CanRender(texture_ref.get()));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Check that we can still manipulate it and it effects the manager.
-  manager_->SetLevelInfo(texture_ref.get(),
-                         GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         1,
-                         1,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_TRUE(manager_->CanRender(texture_ref.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
   texture_ref = NULL;
 }
 
 TEST_F(TextureTest, GetLevelImage) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   Texture* texture = texture_ref_->texture();
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Set image.
   scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
   manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get());
   EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Remove it.
   manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, NULL);
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get());
   // Image should be reset when SetLevelInfo is called.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
 }
 
 namespace {
 
 bool InSet(std::set<std::string>* string_set, const std::string& str) {
   std::pair<std::set<std::string>::iterator, bool> result =
       string_set->insert(str);
   return !result.second;
 }
 
 }  // anonymous namespace
 
 TEST_F(TextureTest, AddToSignature) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   std::string signature1;
   std::string signature2;
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature1);
 
   std::set<std::string> string_set;
   EXPECT_FALSE(InSet(&string_set, signature1));
 
   // check changing 1 thing makes a different signature.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         4,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 2));
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // check putting it back makes the same signature.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check setting cleared status does not change signature.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check changing other settings changes signature.
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         4,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         2,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         1,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         1, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGB,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGB, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_FLOAT,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_FLOAT, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // put it back
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         GL_TEXTURE_2D,
-                         1,
-                         GL_RGBA,
-                         2,
-                         2,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         false);
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // check changing parameters changes signature.
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
   manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
@@ skipping 63 matching lines @@
 
  protected:
   struct LevelInfo {
     LevelInfo(GLenum target,
               GLenum format,
               GLsizei width,
               GLsizei height,
               GLsizei depth,
               GLint border,
               GLenum type,
-              bool cleared)
+              const gfx::Rect& cleared_rect)
         : target(target),
           format(format),
           width(width),
           height(height),
           depth(depth),
           border(border),
           type(type),
-          cleared(cleared) {}
+          cleared_rect(cleared_rect) {}
 
     LevelInfo()
         : target(0),
           format(0),
           width(-1),
           height(-1),
           depth(1),
           border(0),
-          type(0),
-          cleared(false) {}
+          type(0) {}
 
     bool operator==(const LevelInfo& other) const {
       return target == other.target && format == other.format &&
              width == other.width && height == other.height &&
              depth == other.depth && border == other.border &&
-             type == other.type && cleared == other.cleared;
+             type == other.type && cleared_rect == other.cleared_rect;
     }
 
     GLenum target;
     GLenum format;
     GLsizei width;
     GLsizei height;
     GLsizei depth;
     GLint border;
     GLenum type;
-    bool cleared;
+    gfx::Rect cleared_rect;
   };
 
   void SetLevelInfo(TextureRef* texture_ref,
                     GLint level,
                     const LevelInfo& info) {
-    manager_->SetLevelInfo(texture_ref,
-                           info.target,
-                           level,
-                           info.format,
-                           info.width,
-                           info.height,
-                           info.depth,
-                           info.border,
-                           info.format,
-                           info.type,
-                           info.cleared);
+    manager_->SetLevelInfo(texture_ref, info.target, level, info.format,
+                           info.width, info.height, info.depth, info.border,
+                           info.format, info.type, info.cleared_rect);
   }
 
   static LevelInfo GetLevelInfo(const TextureRef* texture_ref,
                                 GLint target,
                                 GLint level) {
     const Texture* texture = texture_ref->texture();
     LevelInfo info;
     info.target = target;
     EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width,
                                       &info.height, &info.depth));
     EXPECT_TRUE(texture->GetLevelType(target, level, &info.type,
                                       &info.format));
-    info.cleared = texture->IsLevelCleared(target, level);
+    info.cleared_rect = texture->GetLevelClearedRect(target, level);
     return info;
   }
 
   Texture* Produce(TextureRef* texture_ref) {
     Texture* texture = manager_->Produce(texture_ref);
     EXPECT_TRUE(texture != NULL);
     return texture;
   }
 
   void Consume(GLuint client_id, Texture* texture) {
     EXPECT_TRUE(manager_->Consume(client_id, texture));
   }
 
   scoped_refptr<TextureRef> texture2_;
 
  private:
   static const GLuint kClient2Id;
   static const GLuint kService2Id;
 };
 
 const GLuint ProduceConsumeTextureTest::kClient2Id = 2;
 const GLuint ProduceConsumeTextureTest::kService2Id = 12;
 
 TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  LevelInfo level0(
-      GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE, true);
+  LevelInfo level0(GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE,
+                   gfx::Rect(4, 4));
   SetLevelInfo(texture_ref_.get(), 0, level0);
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1);
   LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2);
   Texture* produced_texture = Produce(texture_ref_.get());
   EXPECT_EQ(produced_texture, texture);
 
   // Make this texture bigger with more levels, and make sure they get
   // clobbered correctly during Consume().
   manager_->SetTarget(texture2_.get(), GL_TEXTURE_2D);
-  SetLevelInfo(
-      texture2_.get(),
-      0,
-      LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1, 0, GL_UNSIGNED_BYTE, false));
+  SetLevelInfo(texture2_.get(), 0, LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1,
+                                             0, GL_UNSIGNED_BYTE, gfx::Rect()));
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_.get()));
   texture = texture2_->texture();
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size());
 
   GLuint client_id = texture2_->client_id();
   manager_->RemoveTexture(client_id);
   Consume(client_id, produced_texture);
   scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
   EXPECT_EQ(produced_texture, restored_texture->texture());
   EXPECT_EQ(level0, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 0));
   EXPECT_EQ(level1, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 1));
   EXPECT_EQ(level2, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 2));
   texture = restored_texture->texture();
   EXPECT_EQ(64U + 16U + 4U, texture->estimated_size());
   GLint w, h;
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h, nullptr));
 
   // However the old texture ref still exists if it was referenced somewhere.
   EXPECT_EQ(1024U + 256U + 64U + 16U + 4U,
             texture2_->texture()->estimated_size());
 }
 
 TEST_F(ProduceConsumeTextureTest, ProduceConsumeClearRectangle) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_RECTANGLE_ARB);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture->target());
-  LevelInfo level0(
-      GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
+  LevelInfo level0(GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0,
+                   GL_UNSIGNED_BYTE, gfx::Rect());
   SetLevelInfo(texture_ref_.get(), 0, level0);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   Texture* produced_texture = Produce(texture_ref_.get());
   EXPECT_EQ(produced_texture, texture);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB),
             produced_texture->target());
 
   GLuint client_id = texture2_->client_id();
   manager_->RemoveTexture(client_id);
   Consume(client_id, produced_texture);
   scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
   EXPECT_EQ(produced_texture, restored_texture->texture());
 
   // See if we can clear the previously uncleared level now.
   EXPECT_EQ(level0,
             GetLevelInfo(restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
   EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(manager_->ClearTextureLevel(
       decoder_.get(), restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 TEST_F(ProduceConsumeTextureTest, ProduceConsumeExternal) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
-  LevelInfo level0(
-      GL_TEXTURE_EXTERNAL_OES, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
+  LevelInfo level0(GL_TEXTURE_EXTERNAL_OES, GL_RGBA, 1, 1, 1, 0,
+                   GL_UNSIGNED_BYTE, gfx::Rect());
   SetLevelInfo(texture_ref_.get(), 0, level0);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   Texture* produced_texture = Produce(texture_ref_.get());
   EXPECT_EQ(produced_texture, texture);
 
   GLuint client_id = texture2_->client_id();
   manager_->RemoveTexture(client_id);
   Consume(client_id, produced_texture);
   scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
   EXPECT_EQ(produced_texture, restored_texture->texture());
   EXPECT_EQ(level0,
             GetLevelInfo(restored_texture.get(), GL_TEXTURE_EXTERNAL_OES, 0));
 }
 
 TEST_P(ProduceConsumeTextureTest, ProduceConsumeTextureWithImage) {
   GLenum target = GetParam();
   manager_->SetTarget(texture_ref_.get(), target);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(target), texture->target());
   scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
-  manager_->SetLevelInfo(texture_ref_.get(),
-                         target,
-                         0,
-                         GL_RGBA,
-                         0,
-                         0,
-                         1,
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         true);
+  manager_->SetLevelInfo(texture_ref_.get(), target, 0, GL_RGBA, 0, 0, 1, 0,
+                         GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   manager_->SetLevelImage(texture_ref_.get(), target, 0, image.get());
   GLuint service_id = texture->service_id();
   Texture* produced_texture = Produce(texture_ref_.get());
 
   GLuint client_id = texture2_->client_id();
   manager_->RemoveTexture(client_id);
   Consume(client_id, produced_texture);
   scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
   EXPECT_EQ(produced_texture, restored_texture->texture());
   EXPECT_EQ(service_id, restored_texture->service_id());
   EXPECT_EQ(image.get(), restored_texture->texture()->GetLevelImage(target, 0));
 }
 
 static const GLenum kTextureTargets[] = {GL_TEXTURE_2D, GL_TEXTURE_EXTERNAL_OES,
                                          GL_TEXTURE_RECTANGLE_ARB, };
 
 INSTANTIATE_TEST_CASE_P(Target,
                         ProduceConsumeTextureTest,
                         ::testing::ValuesIn(kTextureTargets));
 
 TEST_F(ProduceConsumeTextureTest, ProduceConsumeCube) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
-  LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-                  GL_RGBA,
-                  1,
-                  1,
-                  1,
-                  0,
-                  GL_UNSIGNED_BYTE,
-                  true);
-  LevelInfo face5(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
-                  GL_RGBA,
-                  3,
-                  3,
-                  1,
-                  0,
-                  GL_UNSIGNED_BYTE,
-                  true);
+  LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_RGBA, 1, 1, 1, 0,
+                  GL_UNSIGNED_BYTE, gfx::Rect(1, 1));
+  LevelInfo face5(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_RGBA, 3, 3, 1, 0,
+                  GL_UNSIGNED_BYTE, gfx::Rect(1, 1));
   SetLevelInfo(texture_ref_.get(), 0, face0);
   SetLevelInfo(texture_ref_.get(), 0, face5);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   Texture* produced_texture = Produce(texture_ref_.get());
   EXPECT_EQ(produced_texture, texture);
 
   GLuint client_id = texture2_->client_id();
   manager_->RemoveTexture(client_id);
   Consume(client_id, produced_texture);
   scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
@@ skipping 100 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   ref2 = NULL;
   texture_manager2_->RemoveTexture(20);
   testing::Mock::VerifyAndClearExpectations(gl_.get());
 }
 
 TEST_F(SharedTextureTest, TextureSafetyAccounting) {
   EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
   EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
 
   // Newly created texture is renderable.
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
 
   // Associate new texture ref to other texture manager, should account for it
   // too.
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
 
   // Make texture renderable but uncleared on one texture manager, should affect
   // other one.
   texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
   EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
   EXPECT_TRUE(texture_manager2_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
 
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  0,
-                                  GL_RGBA,
-                                  1,
-                                  1,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  false);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
   EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures());
-  EXPECT_TRUE(texture_manager1_->HaveUnclearedMips());
   EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
   EXPECT_TRUE(texture_manager2_->HaveUnsafeTextures());
-  EXPECT_TRUE(texture_manager2_->HaveUnclearedMips());
 
   // Make texture cleared on one texture manager, should affect other one.
   texture_manager1_->SetLevelCleared(ref1.get(), GL_TEXTURE_2D, 0, true);
   EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
   EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
-  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
 }
 
 TEST_F(SharedTextureTest, FBOCompletenessCheck) {
   const GLenum kCompleteValue = GL_FRAMEBUFFER_COMPLETE;
   FramebufferManager framebuffer_manager1(1, 1);
   texture_manager1_->set_framebuffer_manager(&framebuffer_manager1);
   FramebufferManager framebuffer_manager2(1, 1);
   texture_manager2_->set_framebuffer_manager(&framebuffer_manager2);
 
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   framebuffer_manager1.CreateFramebuffer(10, 10);
   scoped_refptr<Framebuffer> framebuffer1 =
       framebuffer_manager1.GetFramebuffer(10);
   framebuffer1->AttachTexture(
       GL_COLOR_ATTACHMENT0, ref1.get(), GL_TEXTURE_2D, 0, 0);
   EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get()));
   EXPECT_NE(kCompleteValue, framebuffer1->IsPossiblyComplete());
 
   // Make FBO complete in manager 1.
   texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  0,
-                                  GL_RGBA,
-                                  1,
-                                  1,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  true);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                                  gfx::Rect(1, 1));
   EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
   framebuffer_manager1.MarkAsComplete(framebuffer1.get());
   EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get()));
 
   // Share texture with manager 2.
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   framebuffer_manager2.CreateFramebuffer(20, 20);
   scoped_refptr<Framebuffer> framebuffer2 =
       framebuffer_manager2.GetFramebuffer(20);
   framebuffer2->AttachTexture(
       GL_COLOR_ATTACHMENT0, ref2.get(), GL_TEXTURE_2D, 0, 0);
   EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get()));
   EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
   framebuffer_manager2.MarkAsComplete(framebuffer2.get());
   EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get()));
 
   // Change level for texture, both FBOs should be marked incomplete
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  0,
-                                  GL_RGBA,
-                                  1,
-                                  1,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  true);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 0, GL_RGBA, 1, 1,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                                  gfx::Rect(1, 1));
   EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get()));
   EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
   framebuffer_manager1.MarkAsComplete(framebuffer1.get());
   EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get()));
   EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get()));
   EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
   framebuffer_manager2.MarkAsComplete(framebuffer2.get());
   EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get()));
 
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _))
       .Times(2)
       .RetiresOnSaturation();
   framebuffer_manager1.RemoveFramebuffer(10);
   framebuffer_manager2.RemoveFramebuffer(20);
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
 }
 
 TEST_F(SharedTextureTest, Memory) {
   size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged);
   size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged);
 
   // Newly created texture is unrenderable.
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  0,
-                                  GL_RGBA,
-                                  10,
-                                  10,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  false);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 0, GL_RGBA, 10, 10,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
 
   EXPECT_LT(0u, ref1->texture()->estimated_size());
   EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
             memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
 
   // Associate new texture ref to other texture manager, it doesn't account for
   // the texture memory, the first memory tracker still has it.
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
@@ skipping 17 matching lines @@
   EXPECT_EQ(initial_memory2,
             memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
 }
 
 TEST_F(SharedTextureTest, Images) {
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
 
   texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  1,
-                                  GL_RGBA,
-                                  2,
-                                  2,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  true);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                                  gfx::Rect(2, 2));
   EXPECT_FALSE(ref1->texture()->HasImages());
   EXPECT_FALSE(ref2->texture()->HasImages());
   EXPECT_FALSE(texture_manager1_->HaveImages());
   EXPECT_FALSE(texture_manager2_->HaveImages());
   scoped_refptr<gfx::GLImage> image1(new gfx::GLImageStub);
   texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image1.get());
   EXPECT_TRUE(ref1->texture()->HasImages());
   EXPECT_TRUE(ref2->texture()->HasImages());
   EXPECT_TRUE(texture_manager1_->HaveImages());
   EXPECT_TRUE(texture_manager2_->HaveImages());
   scoped_refptr<gfx::GLImage> image2(new gfx::GLImageStub);
   texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image2.get());
   EXPECT_TRUE(ref1->texture()->HasImages());
   EXPECT_TRUE(ref2->texture()->HasImages());
   EXPECT_TRUE(texture_manager1_->HaveImages());
   EXPECT_TRUE(texture_manager2_->HaveImages());
-  texture_manager1_->SetLevelInfo(ref1.get(),
-                                  GL_TEXTURE_2D,
-                                  1,
-                                  GL_RGBA,
-                                  2,
-                                  2,
-                                  1,
-                                  0,
-                                  GL_RGBA,
-                                  GL_UNSIGNED_BYTE,
-                                  true);
+  texture_manager1_->SetLevelInfo(ref1.get(), GL_TEXTURE_2D, 1, GL_RGBA, 2, 2,
+                                  1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                                  gfx::Rect(2, 2));
   EXPECT_FALSE(ref1->texture()->HasImages());
   EXPECT_FALSE(ref2->texture()->HasImages());
   EXPECT_FALSE(texture_manager1_->HaveImages());
   EXPECT_FALSE(texture_manager1_->HaveImages());
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
@@ skipping 252 matching lines @@
   ExpectValid(GL_DEPTH_COMPONENT, GL_FLOAT, GL_DEPTH_COMPONENT32F);
   ExpectValid(GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH24_STENCIL8);
   ExpectValid(GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
               GL_DEPTH32F_STENCIL8);
 
   ExpectInvalid(GL_RGB_INTEGER, GL_INT, GL_RGBA8);
 }
 
 }  // namespace gles2
 }  // namespace gpu