cc: Reduce command buffer flushes related to creating texture 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 198 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) {
+    bool use_rgba_4444_texture_format,
+    size_t texture_id_allocation_chunk_size) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface,
                            shared_bitmap_manager,
                            highp_threshold_min,
-                           use_rgba_4444_texture_format));
+                           use_rgba_4444_texture_format,
+                           texture_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 = context3d->createTexture();
+      resource->gl_id = NextTextureId();
       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 123 matching lines @@
   sk_canvas_.reset(new SkCanvas(sk_bitmap_));
 }
 
 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)
+                                   bool use_rgba_4444_texture_format,
+                                   size_t texture_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) {
+      use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
+      texture_id_allocation_chunk_size_(texture_id_allocation_chunk_size) {
   DCHECK(output_surface_->HasClient());
+  DCHECK(texture_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;
@@ skipping 37 matching lines @@
   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();
+  }
   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));
-      GLC(context3d, texture_id = context3d->createTexture());
+      texture_id = NextTextureId();
       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 537 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();
+
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
 
   // Create and set texture properties. Allocation is delayed until needed.
-  GLC(context3d, resource->gl_id = context3d->createTexture());
   GLC(context3d, context3d->bindTexture(resource->target, resource->gl_id));
   GLC(context3d,
       context3d->texParameteri(
           resource->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(context3d,
       context3d->texParameteri(
           resource->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   GLC(context3d,
       context3d->texParameteri(
           resource->target, GL_TEXTURE_WRAP_S, resource->wrap_mode));
@@ skipping 158 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