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

cc/resources/resource_provider.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 <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 12 matching lines @@
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
+class IdAllocator {
+ public:
+  virtual ~IdAllocator() {}
+
+  virtual unsigned NextId() = 0;
+
+ protected:
+  IdAllocator(WebGraphicsContext3D* context3d, size_t id_allocation_chunk_size)
+      : context3d_(context3d),
+        id_allocation_chunk_size_(id_allocation_chunk_size),
+        ids_(new WebKit::WebGLId[id_allocation_chunk_size]),
+        next_id_index_(id_allocation_chunk_size) {
+    DCHECK(id_allocation_chunk_size_);
+  }
+
+  WebGraphicsContext3D* context3d_;
+  const size_t id_allocation_chunk_size_;
+  scoped_ptr<WebKit::WebGLId[]> ids_;
+  size_t next_id_index_;
+};
+
 namespace {
 
 // Measured in seconds.
 const double kSoftwareUploadTickRate = 0.000250;
 const double kTextureUploadTickRate = 0.004;
 
 GLenum TextureToStorageFormat(ResourceFormat format) {
   GLenum storage_format = GL_RGBA8_OES;
   switch (format) {
     case RGBA_8888:
@@ skipping 40 matching lines @@
     // Active unit being GL_TEXTURE0 is effectively the ground state.
     if (unit_ != GL_TEXTURE0)
       GLC(context3d_, context3d_->activeTexture(GL_TEXTURE0));
   }
 
  private:
   WebGraphicsContext3D* context3d_;
   GLenum unit_;
 };
 
+class TextureIdAllocator : public IdAllocator {
+ public:
+  TextureIdAllocator(WebGraphicsContext3D* context3d,
+                     size_t texture_id_allocation_chunk_size)
+      : IdAllocator(context3d, texture_id_allocation_chunk_size) {
+  }
+  virtual ~TextureIdAllocator() {
+    context3d_->deleteTextures(id_allocation_chunk_size_ - next_id_index_,
+                               ids_.get() + next_id_index_);
+  }
+
+  // Overridden from IdAllocator:
+  virtual unsigned NextId() OVERRIDE {
+    if (next_id_index_ == id_allocation_chunk_size_) {
+      context3d_->genTextures(id_allocation_chunk_size_, ids_.get());
+      next_id_index_ = 0;
+    }
+
+    return ids_[next_id_index_++];
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TextureIdAllocator);
+};
+
+class BufferIdAllocator : public IdAllocator {
+ public:
+  BufferIdAllocator(WebGraphicsContext3D* context3d,
+                    size_t buffer_id_allocation_chunk_size)
+      : IdAllocator(context3d, buffer_id_allocation_chunk_size) {
+  }
+  virtual ~BufferIdAllocator() {
+    context3d_->deleteBuffers(id_allocation_chunk_size_ - next_id_index_,
+                              ids_.get() + next_id_index_);
+  }
+
+  // Overridden from IdAllocator:
+  virtual unsigned NextId() OVERRIDE {
+    if (next_id_index_ == id_allocation_chunk_size_) {
+      context3d_->genBuffers(id_allocation_chunk_size_, ids_.get());
+      next_id_index_ = 0;
+    }
+
+    return ids_[next_id_index_++];
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BufferIdAllocator);
+};
+
 }  // namespace
 
 ResourceProvider::Resource::Resource()
     : child_id(0),
       gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
@@ skipping 107 matching lines @@
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
-    size_t texture_id_allocation_chunk_size) {
+    size_t id_allocation_chunk_size) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface,
                            shared_bitmap_manager,
                            highp_threshold_min,
                            use_rgba_4444_texture_format,
-                           texture_id_allocation_chunk_size));
+                           id_allocation_chunk_size));
 
   bool success = false;
   if (resource_provider->Context3d()) {
     success = resource_provider->InitializeGL();
   } else {
     resource_provider->InitializeSoftware();
     success = true;
   }
 
   if (!success)
@@ skipping 405 matching lines @@
 
   if (resource->external) {
     if (!resource->gl_id && resource->mailbox.IsTexture()) {
       WebGraphicsContext3D* context3d = Context3d();
       DCHECK(context3d);
       if (resource->mailbox.sync_point()) {
         GLC(context3d,
             context3d->waitSyncPoint(resource->mailbox.sync_point()));
         resource->mailbox.ResetSyncPoint();
       }
-      resource->gl_id = NextTextureId();
+      resource->gl_id = texture_id_allocator_->NextId();
       GLC(context3d, context3d->bindTexture(resource->target, resource->gl_id));
       GLC(context3d,
           context3d->consumeTextureCHROMIUM(resource->target,
                                             resource->mailbox.data()));
     }
   }
 
   resource->lock_for_read_count++;
   if (resource->enable_read_lock_fences)
     resource->read_lock_fence = current_read_lock_fence_;
@@ skipping 124 matching lines @@
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
 ResourceProvider::ResourceProvider(OutputSurface* output_surface,
                                    SharedBitmapManager* shared_bitmap_manager,
                                    int highp_threshold_min,
                                    bool use_rgba_4444_texture_format,
-                                   size_t texture_id_allocation_chunk_size)
+                                   size_t id_allocation_chunk_size)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_usage_hint_(false),
       use_shallow_flush_(false),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
-      texture_id_allocation_chunk_size_(texture_id_allocation_chunk_size) {
+      id_allocation_chunk_size_(id_allocation_chunk_size) {
   DCHECK(output_surface_->HasClient());
-  DCHECK(texture_id_allocation_chunk_size_);
+  DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
   CleanUpGLIfNeeded();
 
   default_resource_type_ = Bitmap;
   max_texture_size_ = INT_MAX / 2;
   best_texture_format_ = RGBA_8888;
 }
 
 bool ResourceProvider::InitializeGL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!texture_uploader_);
   DCHECK_NE(GLTexture, default_resource_type_);
+  DCHECK(!texture_id_allocator_);
+  DCHECK(!buffer_id_allocator_);
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
 
   if (!context3d->makeContextCurrent())
     return false;
 
   default_resource_type_ = GLTexture;
 
   const ContextProvider::Capabilities& caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   bool use_map_sub = caps.map_sub;
   bool use_bgra = caps.texture_format_bgra8888;
   use_texture_storage_ext_ = caps.texture_storage;
   use_shallow_flush_ = caps.shallow_flush;
   use_texture_usage_hint_ = caps.texture_usage;
   use_compressed_texture_etc1_ = caps.texture_format_etc1;
 
   texture_uploader_ =
       TextureUploader::Create(context3d, use_map_sub, use_shallow_flush_);
   GLC(context3d, context3d->getIntegerv(GL_MAX_TEXTURE_SIZE,
                                         &max_texture_size_));
   best_texture_format_ = PlatformColor::BestTextureFormat(use_bgra);
 
+  texture_id_allocator_.reset(
+      new TextureIdAllocator(context3d, id_allocation_chunk_size_));
+  buffer_id_allocator_.reset(
+      new BufferIdAllocator(context3d, id_allocation_chunk_size_));
+
   return true;
 }
 
 void ResourceProvider::CleanUpGLIfNeeded() {
   WebGraphicsContext3D* context3d = Context3d();
   if (default_resource_type_ != GLTexture) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!context3d);
     DCHECK(!texture_uploader_);
     return;
   }
 
   DCHECK(context3d);
   context3d->makeContextCurrent();
   texture_uploader_.reset();
-  if (!unused_texture_ids_.empty()) {
-    size_t size = unused_texture_ids_.size();
-    scoped_ptr<WebKit::WebGLId[]> ids(new WebKit::WebGLId[size]);
-    for (size_t i = 0; i < size; ++i)
-      ids[i] = unused_texture_ids_[i];
-    GLC(context3d, context3d->deleteTextures(size, ids.get()));
-    unused_texture_ids_.clear();
-  }
+  texture_id_allocator_.reset();
+  buffer_id_allocator_.reset();
   Finish();
 }
 
 int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
 
   int child = next_child_++;
@@ skipping 105 matching lines @@
     } else {
       unsigned texture_id;
       // NOTE: If the parent is a browser and the child a renderer, the parent
       // is not supposed to have its context wait, because that could induce
       // deadlocks and/or security issues. The caller is responsible for
       // waiting asynchronously, and resetting sync_point before calling this.
       // However if the parent is a renderer (e.g. browser tag), it may be ok
       // (and is simpler) to wait.
       if (it->sync_point)
         GLC(context3d, context3d->waitSyncPoint(it->sync_point));
-      texture_id = NextTextureId();
+      texture_id = texture_id_allocator_->NextId();
       GLC(context3d, context3d->bindTexture(it->target, texture_id));
       GLC(context3d,
           context3d->consumeTextureCHROMIUM(it->target, it->mailbox.name));
       resource = Resource(texture_id,
                           it->size,
                           it->target,
                           it->filter,
                           0,
                           GL_CLAMP_TO_EDGE,
                           TextureUsageAny,
@@ skipping 264 matching lines @@
   Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
   DCHECK_NE(ETC1, resource->format);
 
   if (resource->type == GLTexture) {
     WebGraphicsContext3D* context3d = Context3d();
     DCHECK(context3d);
     if (!resource->gl_pixel_buffer_id)
-      resource->gl_pixel_buffer_id = context3d->createBuffer();
+      resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
     context3d->bufferData(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->size.height() * RoundUp(bytes_per_pixel
             * resource->size.width(), 4u),
         NULL,
         GL_DYNAMIC_DRAW);
@@ skipping 252 matching lines @@
 }
 
 void ResourceProvider::LazyCreate(Resource* resource) {
   if (resource->type != GLTexture || resource->gl_id != 0)
     return;
 
   // Early out for resources that don't require texture creation.
   if (resource->texture_pool == 0)
     return;
 
-  resource->gl_id = NextTextureId();
+  resource->gl_id = texture_id_allocator_->NextId();
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
 
   // Create and set texture properties. Allocation is delayed until needed.
   GLC(context3d, context3d->bindTexture(resource->target, resource->gl_id));
   GLC(context3d,
       context3d->texParameteri(
           resource->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(context3d,
@@ skipping 163 matching lines @@
   GLint active_unit = 0;
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
-unsigned ResourceProvider::NextTextureId() {
-  if (unused_texture_ids_.empty()) {
-    size_t size = texture_id_allocation_chunk_size_;
-    scoped_ptr<WebKit::WebGLId[]> ids(new WebKit::WebGLId[size]);
-    WebGraphicsContext3D* context3d = Context3d();
-    DCHECK(context3d);
-    GLC(context3d, context3d->genTextures(size, ids.get()));
-    unused_texture_ids_.assign(ids.get(), ids.get() + size);
-  }
-
-  unsigned gl_id = unused_texture_ids_.front();
-  unused_texture_ids_.pop_front();
-
-  return gl_id;
-}
-
 }  // namespace cc