Command buffer: clear rect for a specific layer/level of the uncleared texture for CopyTexSubImage3D

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 160 matching lines @@
   void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                     uint64_t process_tracing_id,
                     const std::string& dump_name) override {}
   bool EmulatingRGB() const override { return false; }
   void GetTextureMatrix(float matrix[16]) override {}
 
  protected:
   ~GLStreamTextureImageStub() override {}
 };
 
+// TODO(yunchao) add test cases for 3D texture and 2D_ARRAY texture
+
 TEST_F(TextureManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   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);
@@ skipping 1082 matching lines @@
   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,
+  manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1,
                          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_TEXTURE_CUBE_MAP_NEGATIVE_Z, 1, 0, 0, 0, 4, 5, 1));
   // Check bad level.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 5, 1));
   // Check bad xoffset.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, -1, 0, 0, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, -1, 0, 0, 4, 5, 1));
   // Check bad xoffset + width > width.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 1, 0, 0, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 1, 0, 0, 4, 5, 1));
   // Check bad yoffset.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, -1, 0, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, -1, 0, 4, 5, 1));
   // Check bad yoffset + height > height.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 1, 0, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 1, 0, 4, 5, 1));
   // Check bad zoffset.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, -1, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, -1, 4, 5, 1));
   // Check bad zoffset + depth > depth.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 1, 4, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 1, 4, 5, 1));
   // Check bad width.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 5, 5, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 5, 5, 1));
   // Check bad height.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 6, 6));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 6, 1));
   // Check bad depth.
-  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 7));
+  EXPECT_FALSE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 2));
   // Check valid full size
-  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 6));
+  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 1));
   // Check valid particial size.
-  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 1, 1, 1, 2, 3, 4));
+  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 1, 1, 0, 2, 3, 1));
   manager_->RemoveTexture(kClient1Id);
-  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 6));
+  EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 1));
 }
 
 TEST_F(TextureTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
   TextureManager manager(NULL,
                          feature_info.get(),
                          kMaxTextureSize,
@@ skipping 159 matching lines @@
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(0, texture->num_uncleared_mips());
   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, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, texture->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
+  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, 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, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, texture->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
+  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, 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, 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());
-  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
+  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, 0, true);
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, texture->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
+  manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, 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, gfx::Rect());
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, texture->num_uncleared_mips());
@@ skipping 28 matching lines @@
   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, gfx::Rect(2, 2));
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   Texture* texture3 = texture_ref3->texture();
   EXPECT_EQ(1, texture3->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_ref2.get(), GL_TEXTURE_2D, 0, true);
+  manager_->SetLevelCleared(texture_ref2.get(), GL_TEXTURE_2D, 0, 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);
+  manager_->SetLevelCleared(texture_ref3.get(), GL_TEXTURE_2D, 0, 0, true);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, texture3->num_uncleared_mips());
 
   manager_->SetLevelInfo(texture_ref2.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(1, 1, 1, 1));
   manager_->SetLevelInfo(texture_ref3.get(), GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4, 4, 4));
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
@@ skipping 87 matching lines @@
       .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, gfx::Rect(2, 2));
   Texture* texture = texture_ref_->texture();
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1, 0) == NULL);
   // Set image.
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
-  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get(),
+  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, 0, image.get(),
                           Texture::BOUND);
-  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
-  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_2D, 1, 0) == NULL);
   // Remove it.
-  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, nullptr,
+  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, 0, nullptr,
                           Texture::UNBOUND);
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
-  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get(),
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1, 0) == NULL);
+  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, 0, image.get(),
                           Texture::UNBOUND);
   // 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, gfx::Rect(2, 2));
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
-  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_2D, 1, 0) == NULL);
 }
 
 TEST_F(TextureTest, GetLevelStreamTextureImage) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0,
                          GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                          gfx::Rect(2, 2));
   Texture* texture = texture_ref_->texture();
 
   // Set image.
   scoped_refptr<GLStreamTextureImage> image(new GLStreamTextureImageStub);
   manager_->SetLevelStreamTextureImage(texture_ref_.get(),
-                                       GL_TEXTURE_EXTERNAL_OES, 0, image.get(),
-                                       Texture::BOUND, 0);
-  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0) == NULL);
+                                       GL_TEXTURE_EXTERNAL_OES, 0, 0,
+                                       image.get(), Texture::BOUND, 0);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0, 0) == NULL);
   EXPECT_FALSE(
-      texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0) == NULL);
+      texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0, 0) ==
+      NULL);
 
   // Replace it as a normal image.
   scoped_refptr<gl::GLImage> image2(new gl::GLImageStub);
-  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0,
+  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0, 0,
                           image2.get(), Texture::BOUND);
-  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0) == NULL);
-  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0) ==
-              NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0, 0)
+              == NULL);
 
   // Image should be reset when SetLevelInfo is called.
   manager_->SetLevelStreamTextureImage(texture_ref_.get(),
-                                       GL_TEXTURE_EXTERNAL_OES, 0, image.get(),
-                                       Texture::UNBOUND, 0);
+                                       GL_TEXTURE_EXTERNAL_OES, 0, 0,
+                                       image.get(), Texture::UNBOUND, 0);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0,
                          GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                          gfx::Rect(2, 2));
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0) == NULL);
-  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0) ==
-              NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0, 0)
+              == NULL);
 }
 
 TEST_F(TextureTest, SetLevelImageState) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
   Texture* texture = texture_ref_->texture();
   // Set image, initially BOUND.
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
-  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 0, image.get(),
+  manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 0, 0, image.get(),
                           Texture::BOUND);
   Texture::ImageState state;
-  texture->GetLevelImage(GL_TEXTURE_2D, 0, &state);
+  texture->GetLevelImage(GL_TEXTURE_2D, 0, 0, &state);
   EXPECT_EQ(state, Texture::BOUND);
   // Change the state.
-  texture->SetLevelImageState(GL_TEXTURE_2D, 0, Texture::COPIED);
-  texture->GetLevelImage(GL_TEXTURE_2D, 0, &state);
+  texture->SetLevelImageState(GL_TEXTURE_2D, 0, 0, Texture::COPIED);
+  texture->GetLevelImage(GL_TEXTURE_2D, 0, 0, &state);
   EXPECT_EQ(state, Texture::COPIED);
 }
 
 TEST_F(TextureTest, SetStreamTextureImageServiceID) {
   manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES);
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0,
                          GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                          gfx::Rect(2, 2));
   Texture* texture = texture_ref_->texture();
 
   GLuint owned_service_id = TextureTestHelper::owned_service_id(texture);
   GLuint service_id = texture->service_id();
   // Initially, the texture should use the same service id that it owns.
   EXPECT_EQ(owned_service_id, service_id);
 
   // Override the service_id.
   GLuint stream_texture_service_id = service_id + 1;
   scoped_refptr<GLStreamTextureImage> image(new GLStreamTextureImageStub);
   manager_->SetLevelStreamTextureImage(
-      texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0, image.get(),
+      texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0, 0, image.get(),
       Texture::BOUND, stream_texture_service_id);
 
   // Make sure that service_id() changed but owned_service_id() didn't.
   EXPECT_EQ(stream_texture_service_id, texture->service_id());
   EXPECT_EQ(owned_service_id, TextureTestHelper::owned_service_id(texture));
 
   // Undo the override.
   manager_->SetLevelStreamTextureImage(texture_ref_.get(),
-                                       GL_TEXTURE_EXTERNAL_OES, 0, image.get(),
-                                       Texture::BOUND, 0);
+                                       GL_TEXTURE_EXTERNAL_OES, 0, 0,
+                                       image.get(), Texture::BOUND, 0);
 
   // The service IDs should be back as they were.
   EXPECT_EQ(service_id, texture->service_id());
   EXPECT_EQ(owned_service_id, TextureTestHelper::owned_service_id(texture));
 
   // Override again, so that we can check delete behavior.
   manager_->SetLevelStreamTextureImage(
-      texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0, image.get(),
+      texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES, 0, 0, image.get(),
       Texture::BOUND, stream_texture_service_id);
 
   // Remove the Texture.  It should delete the texture id that it owns, even
   // though it is overridden.
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(owned_service_id)))
       .Times(1)
       .RetiresOnSaturation();
   manager_->RemoveTexture(kClient1Id);
   texture_ref_ = nullptr;
 }
 
 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, gfx::Rect(2, 2));
   std::string signature1;
   std::string signature2;
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature1);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect(4, 2));
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect(2, 2));
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect());
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, 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, gfx::Rect());
-  signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect());
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect());
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect());
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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, gfx::Rect());
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &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);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   SetParameter(texture_ref_.get(),
                GL_TEXTURE_MIN_FILTER,
                GL_NEAREST_MIPMAP_LINEAR,
                GL_NO_ERROR);
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
   SetParameter(
       texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // Check putting it back genenerates the same signature
   SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D,
+                           1, 0, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check the set was acutally getting different signatures.
-  EXPECT_EQ(11u, string_set.size());
+  EXPECT_EQ(10u, string_set.size());
 }
 
 class ProduceConsumeTextureTest : public TextureTest,
                                   public ::testing::WithParamInterface<GLenum> {
  public:
   void SetUp() override {
     TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external");
     manager_->CreateTexture(kClient2Id, kService2Id);
     texture2_ = manager_->GetTexture(kClient2Id);
 
@@ skipping 73 matching lines @@
   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_rect = texture->GetLevelClearedRect(target, level);
+    info.cleared_rect = texture->GetLevelClearedRect(target, level, 0);
     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) {
@@ skipping 107 matching lines @@
 }
 
 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<gl::GLImage> image(new gl::GLImageStub);
   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(),
+  manager_->SetLevelImage(texture_ref_.get(), target, 0, 0, image.get(),
                           Texture::BOUND);
   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));
+  EXPECT_EQ(image.get(),
+            restored_texture->texture()->GetLevelImage(target, 0, 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) {
@@ skipping 152 matching lines @@
   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, gfx::Rect());
   EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures());
   EXPECT_TRUE(texture_manager1_->HaveUnclearedMips());
   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);
+  texture_manager1_->SetLevelCleared(ref1.get(), GL_TEXTURE_2D, 0, 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);
@@ skipping 115 matching lines @@
 
   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,
                                   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<gl::GLImage> image1(new gl::GLImageStub);
-  texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image1.get(),
-                                   Texture::BOUND);
+  texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, 0,
+                                   image1.get(), Texture::BOUND);
   EXPECT_TRUE(ref1->texture()->HasImages());
   EXPECT_TRUE(ref2->texture()->HasImages());
   EXPECT_TRUE(texture_manager1_->HaveImages());
   EXPECT_TRUE(texture_manager2_->HaveImages());
   scoped_refptr<gl::GLImage> image2(new gl::GLImageStub);
-  texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image2.get(),
-                                   Texture::BOUND);
+  texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, 0,
+                                   image2.get(), Texture::BOUND);
   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,
                                   gfx::Rect(2, 2));
   EXPECT_FALSE(ref1->texture()->HasImages());
   EXPECT_FALSE(ref2->texture()->HasImages());
   EXPECT_FALSE(texture_manager1_->HaveImages());
@@ skipping 263 matching lines @@
   ExpectValid(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH24_STENCIL8);
   ExpectValid(true, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
               GL_DEPTH32F_STENCIL8);
 
   ExpectInvalid(true, GL_RGB_INTEGER, GL_INT, GL_RGBA8);
 }
 
 }  // namespace gles2
 }  // namespace gpu