cc: Reduce command buffer flushes related to creating texture ids.

cc/resources/resource_provider_unittest.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 81 matching lines @@
                                             const WGC3Dbyte* mailbox));
   MOCK_METHOD2(consumeTextureCHROMIUM, void(WGC3Denum target,
                                             const WGC3Dbyte* mailbox));
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
   virtual WebKit::WebGLId NextTextureId() OVERRIDE {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
+  virtual void RetireTextureId(WebKit::WebGLId) OVERRIDE {
+  }
 };
 
 // Shared data between multiple ResourceProviderContext. This contains mailbox
 // contents as well as information about sync points.
 class ContextSharedData {
  public:
   static scoped_ptr<ContextSharedData> Create() {
     return make_scoped_ptr(new ContextSharedData());
   }
 
@@ skipping 360 matching lines @@
       case ResourceProvider::InvalidType:
         NOTREACHED();
         break;
     }
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     CHECK(child_output_surface_->BindToClient(&child_output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
 
     resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), shared_bitmap_manager_.get(), 0, false);
+        output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1);
     child_resource_provider_ = ResourceProvider::Create(
-        child_output_surface_.get(), shared_bitmap_manager_.get(), 0, false);
+        child_output_surface_.get(),
+        shared_bitmap_manager_.get(),
+        0,
+        false,
+        1);
   }
 
   static void CollectResources(ReturnedResourceArray* array,
                                const ReturnedResourceArray& returned) {
     array->insert(array->end(), returned.begin(), returned.end());
   }
 
   static ReturnCallback GetReturnCallback(ReturnedResourceArray* array) {
     return base::Bind(&ResourceProviderTest::CollectResources, array);
   }
@@ skipping 520 matching lines @@
   if (GetParam() != ResourceProvider::Bitmap)
     return;
 
   scoped_ptr<FakeOutputSurface> parent_output_surface =
       FakeOutputSurface::CreateSoftware(
           make_scoped_ptr(new SoftwareOutputDevice));
   FakeOutputSurfaceClient parent_output_surface_client;
   CHECK(parent_output_surface->BindToClient(&parent_output_surface_client));
 
   scoped_ptr<ResourceProvider> parent_resource_provider(
-      ResourceProvider::Create(parent_output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(parent_output_surface.get(),
+                               NULL,
+                               0,
+                               false,
+                               1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
@@ skipping 33 matching lines @@
 
   scoped_ptr<ResourceProviderContext> child_context_owned(
       ResourceProviderContext::Create(shared_data_.get()));
 
   FakeOutputSurfaceClient child_output_surface_client;
   scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
       child_context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(child_output_surface->BindToClient(&child_output_surface_client));
 
   scoped_ptr<ResourceProvider> child_resource_provider(
-      ResourceProvider::Create(child_output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(child_output_surface.get(),
+                               NULL,
+                               0,
+                               false,
+                               1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
@@ skipping 327 matching lines @@
     scoped_ptr<TextureStateTrackingContext> child_context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* child_context = child_context_owned.get();
 
     FakeOutputSurfaceClient child_output_surface_client;
     scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
         child_context_owned.PassAs<TestWebGraphicsContext3D>()));
     CHECK(child_output_surface->BindToClient(&child_output_surface_client));
 
     scoped_ptr<ResourceProvider> child_resource_provider(
-        ResourceProvider::Create(child_output_surface.get(), NULL, 0, false));
+        ResourceProvider::Create(child_output_surface.get(),
+                                 NULL,
+                                 0,
+                                 false,
+                                 1));
 
     scoped_ptr<TextureStateTrackingContext> parent_context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* parent_context = parent_context_owned.get();
 
     FakeOutputSurfaceClient parent_output_surface_client;
     scoped_ptr<OutputSurface> parent_output_surface(FakeOutputSurface::Create3d(
         parent_context_owned.PassAs<TestWebGraphicsContext3D>()));
     CHECK(parent_output_surface->BindToClient(&parent_output_surface_client));
 
     scoped_ptr<ResourceProvider> parent_resource_provider(
-        ResourceProvider::Create(parent_output_surface.get(), NULL, 0, false));
+        ResourceProvider::Create(parent_output_surface.get(),
+                                 NULL,
+                                 0,
+                                 false,
+                                 1));
 
     gfx::Size size(1, 1);
     ResourceFormat format = RGBA_8888;
     int child_texture_id = 1;
     int parent_texture_id = 2;
 
     size_t pixel_size = TextureSizeBytes(size, format);
     ASSERT_EQ(4U, pixel_size);
 
     ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
@@ skipping 580 matching lines @@
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
 
   // Check that the texture gets created with the right sampler settings.
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
@@ skipping 60 matching lines @@
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
   EXPECT_CALL(*context,
@@ skipping 24 matching lines @@
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   GLenum texture_pool = GL_TEXTURE_POOL_UNMANAGED_CHROMIUM;
 
   for (int texture_id = 1; texture_id <= 2; ++texture_id) {
     GLint wrap_mode = texture_id == 1 ? GL_CLAMP_TO_EDGE : GL_REPEAT;
     // Check that the texture gets created with the right sampler settings.
     ResourceProvider::ResourceId id =
         resource_provider->CreateGLTexture(size,
@@ skipping 32 matching lines @@
   scoped_ptr<base::SharedMemory> shared_memory(
       CreateAndFillSharedMemory(size, kBadBeef));
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
           new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
       base::Bind(&EmptyReleaseCallback));
   TextureMailbox mailbox(shared_memory.get(), size);
 
   ResourceProvider::ResourceId id =
       resource_provider->CreateResourceFromTextureMailbox(
           mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
@@ skipping 14 matching lines @@
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   unsigned texture_id = 1;
   unsigned sync_point = 30;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
@@ skipping 43 matching lines @@
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   unsigned texture_id = 1;
   unsigned sync_point = 30;
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
@@ skipping 30 matching lines @@
     EXPECT_CALL(*context, insertSyncPoint());
     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
 
     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
     EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
   }
 }
 
 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
  public:
-  MOCK_METHOD0(createTexture, WebGLId());
-  MOCK_METHOD1(deleteTexture, void(WebGLId texture_id));
+  MOCK_METHOD0(NextTextureId, WebGLId());
+  MOCK_METHOD1(RetireTextureId, void(WebGLId id));
   MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
   MOCK_METHOD9(texImage2D,
                void(WGC3Denum target,
                     WGC3Dint level,
                     WGC3Denum internalformat,
                     WGC3Dsizei width,
                     WGC3Dsizei height,
                     WGC3Dint border,
                     WGC3Denum format,
                     WGC3Denum type,
@@ skipping 56 matching lines @@
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   gfx::Rect rect(0, 0, 2, 2);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
   // Lazy allocation. Don't allocate when creating the resource.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
 
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   resource_provider->CreateForTesting(id);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Do allocate when we set the pixels.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
 
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
   resource_provider->SetPixels(id, pixels, rect, rect, offset);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Same for async version.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   resource_provider->AcquirePixelBuffer(id);
 
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
   ASSERT_TRUE(resource_provider->DidSetPixelsComplete(id));
 
   resource_provider->ReleasePixelBuffer(id);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   resource_provider->AcquirePixelBuffer(id);
 
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
 
   EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
 
   resource_provider->ReleasePixelBuffer(id);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, PixelBuffer_Bitmap) {
   if (GetParam() != ResourceProvider::Bitmap)
     return;
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
           new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   const uint32_t kBadBeef = 0xbadbeef;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   resource_provider->AcquirePixelBuffer(id);
 
   void* data = resource_provider->MapPixelBuffer(id);
   ASSERT_TRUE(!!data);
   memcpy(data, &kBadBeef, sizeof(kBadBeef));
   resource_provider->UnmapPixelBuffer(id);
 
@@ skipping 25 matching lines @@
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   resource_provider->AcquirePixelBuffer(id);
 
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
       .Times(1);
   resource_provider->BeginSetPixels(id);
 
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
   resource_provider->ForceSetPixelsToComplete(id);
 
   resource_provider->ReleasePixelBuffer(id);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, PixelBufferLostContext) {
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new NiceMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(2, 2);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   int texture_id = 123;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
-  EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillRepeatedly(Return(texture_id));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                GL_INNOCENT_CONTEXT_RESET_ARB);
   resource_provider->AcquirePixelBuffer(id);
   uint8_t* buffer = resource_provider->MapPixelBuffer(id);
   EXPECT_TRUE(buffer == NULL);
   resource_provider->UnmapPixelBuffer(id);
   resource_provider->ReleasePixelBuffer(id);
@@ skipping 15 matching lines @@
 
   const int kWidth = 2;
   const int kHeight = 2;
   gfx::Size size(kWidth, kHeight);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   EXPECT_CALL(*context, createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES))
       .WillOnce(Return(kImageId))
       .RetiresOnSaturation();
   resource_provider->AcquireImage(id);
 
   void* dummy_mapped_buffer_address = NULL;
   EXPECT_CALL(*context, mapImageCHROMIUM(kImageId, GL_READ_WRITE))
       .WillOnce(Return(dummy_mapped_buffer_address))
       .RetiresOnSaturation();
   resource_provider->MapImage(id);
 
   const int kStride = 4;
   EXPECT_CALL(*context, getImageParameterivCHROMIUM(kImageId,
                                                     GL_IMAGE_ROWBYTES_CHROMIUM,
                                                     _))
       .WillOnce(SetArgPointee<2>(kStride))
       .RetiresOnSaturation();
   int stride = resource_provider->GetImageStride(id);
   EXPECT_EQ(kStride, stride);
 
   EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
       .Times(1)
       .RetiresOnSaturation();
   resource_provider->UnmapImage(id);
 
-  EXPECT_CALL(*context, createTexture())
+  EXPECT_CALL(*context, NextTextureId())
       .WillOnce(Return(kTextureId))
       .RetiresOnSaturation();
   // Once in CreateTextureId and once in BindForSampling
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(2)
       .RetiresOnSaturation();
   EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
       .Times(1)
       .RetiresOnSaturation();
   {
     ResourceProvider::ScopedSamplerGL lock_gl(
@@ skipping 12 matching lines @@
   resource_provider->UnmapImage(id);
 
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*context, releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*context, deleteTexture(kTextureId))
+  EXPECT_CALL(*context, RetireTextureId(kTextureId))
       .Times(1)
       .RetiresOnSaturation();
   {
     ResourceProvider::ScopedSamplerGL lock_gl(
         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
     EXPECT_EQ(kTextureId, lock_gl.texture_id());
   }
 
   EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId))
       .Times(1)
       .RetiresOnSaturation();
   resource_provider->ReleaseImage(id);
 }
 
 TEST_P(ResourceProviderTest, Image_Bitmap) {
   if (GetParam() != ResourceProvider::Bitmap)
     return;
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
           new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   const uint32_t kBadBeef = 0xbadbeef;
 
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   resource_provider->AcquireImage(id);
 
   const int kStride = 0;
   int stride = resource_provider->GetImageStride(id);
   EXPECT_EQ(kStride, stride);
 
   void* data = resource_provider->MapImage(id);
@@ skipping 30 matching lines @@
 }
 
 TEST(ResourceProviderTest, BasicInitializeGLSoftware) {
   scoped_ptr<ContextSharedData> shared_data = ContextSharedData::Create();
   FakeOutputSurfaceClient client;
   scoped_ptr<FakeOutputSurface> output_surface(
       FakeOutputSurface::CreateDeferredGL(
           scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice)));
   EXPECT_TRUE(output_surface->BindToClient(&client));
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(), NULL, 0, false));
+      ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   CheckCreateResource(ResourceProvider::Bitmap, resource_provider.get(), NULL);
 
   InitializeGLAndCheck(shared_data.get(),
                        resource_provider.get(),
                        output_surface.get());
 
   resource_provider->InitializeSoftware();
   output_surface->ReleaseGL();
   CheckCreateResource(ResourceProvider::Bitmap, resource_provider.get(), NULL);
@@ skipping 11 matching lines @@
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(4, 4);
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(), 0, false));
+  scoped_ptr<ResourceProvider> resource_provider(
+      ResourceProvider::Create(output_surface.get(),
+                               shared_bitmap_manager_.get(),
+                               0,
+                               false,
+                               1));
   int texture_id = 123;
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, ETC1);
   EXPECT_NE(0u, id);
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   resource_provider->AllocateForTesting(id);
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 TEST_P(ResourceProviderTest, CompressedTextureETC1SetPixels) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(4, 4);
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(), 0, false));
+  scoped_ptr<ResourceProvider> resource_provider(
+      ResourceProvider::Create(output_surface.get(),
+                               shared_bitmap_manager_.get(),
+                               0,
+                               false,
+                               1));
   int texture_id = 123;
   uint8_t pixels[8];
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, ETC1);
   EXPECT_NE(0u, id);
-  EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context,
               compressedTexImage2D(
                   _, 0, _, size.width(), size.height(), _, _, _)).Times(1);
   resource_provider->SetPixels(
       id, pixels, gfx::Rect(size), gfx::Rect(size), gfx::Vector2d(0, 0));
 
-  EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
+  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
+class TextureIdAllocationTrackingContext : public TestWebGraphicsContext3D {
+ public:
+  virtual WebKit::WebGLId NextTextureId() OVERRIDE {
+    base::AutoLock lock(namespace_->lock);
+    return namespace_->next_texture_id++;
+  }
+  virtual void RetireTextureId(WebKit::WebGLId) OVERRIDE {
+  }
+  WebKit::WebGLId PeekTextureId() {
+    base::AutoLock lock(namespace_->lock);
+    return namespace_->next_texture_id;
+  }
+};
+
+TEST(ResourceProviderTest, TextureAllocationChunkSize) {
+  scoped_ptr<TextureIdAllocationTrackingContext> context_owned(
+      new TextureIdAllocationTrackingContext);
+  TextureIdAllocationTrackingContext* context = context_owned.get();
+
+  FakeOutputSurfaceClient output_surface_client;
+  scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
+      context_owned.PassAs<TestWebGraphicsContext3D>()));
+  CHECK(output_surface->BindToClient(&output_surface_client));
+
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+
+  {
+    size_t kTextureAllocationChunkSize = 1;
+    scoped_ptr<ResourceProvider> resource_provider(
+        ResourceProvider::Create(output_surface.get(),
+                                 NULL,
+                                 0,
+                                 false,
+                                 kTextureAllocationChunkSize));
+
+    ResourceProvider::ResourceId id = resource_provider->CreateResource(
+        size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+    resource_provider->AllocateForTesting(id);
+    Mock::VerifyAndClearExpectations(context);
+
+    DCHECK_EQ(2u, context->PeekTextureId());
+    resource_provider->DeleteResource(id);
+  }
+
+  {
+    size_t kTextureAllocationChunkSize = 8;
+    scoped_ptr<ResourceProvider> resource_provider(
+        ResourceProvider::Create(output_surface.get(),
+                                 NULL,
+                                 0,
+                                 false,
+                                 kTextureAllocationChunkSize));
+
+    ResourceProvider::ResourceId id = resource_provider->CreateResource(
+        size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+    resource_provider->AllocateForTesting(id);
+    Mock::VerifyAndClearExpectations(context);
+
+    DCHECK_EQ(10u, context->PeekTextureId());
+    resource_provider->DeleteResource(id);
+  }
+}
+
 }  // namespace
 }  // namespace cc