cc: Changes to use GL API for GpuMemoryBuffers

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/debug/alias.h"
@@ skipping 67 matching lines @@
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(),
       format(0),
       filter(0),
+      image_id(0),
       type(static_cast<ResourceType>(0)) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
     unsigned texture_id, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
+      image_id(0),
       type(GLTexture) {}
 
 ResourceProvider::Resource::Resource(
     uint8_t* pixels, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(pixels),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
+      image_id(0),
       type(Bitmap) {}
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     int highp_threshold_min) {
   scoped_ptr<ResourceProvider> resource_provider(
@@ skipping 157 matching lines @@
 
 void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
                                               DeleteStyle style) {
   Resource* resource = &it->second;
   bool lost_resource = lost_output_surface_;
 
   DCHECK(!resource->exported || style != Normal);
   if (style == ForShutdown && resource->exported)
     lost_resource = true;
 
+  if (resource->image_id) {
+    WebGraphicsContext3D* context3d = output_surface_->context3d();
+    DCHECK(context3d);
+    GLC(context3d, context3d->destroyImageCHROMIUM(resource->image_id));
+  }
+
   if (resource->gl_id && !resource->external) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteTexture(resource->gl_id));
   }
   if (resource->gl_upload_query_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteQueryEXT(resource->gl_upload_query_id));
   }
@@ skipping 41 matching lines @@
                                  gfx::Vector2d dest_offset) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
   DCHECK(ReadLockFenceHasPassed(resource));
+  DCHECK(!resource->image_id);
   LazyAllocate(resource);
 
   if (resource->gl_id) {
     DCHECK(!resource->pending_set_pixels);
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(texture_uploader_.get());
     context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
     texture_uploader_->Upload(image,
                               image_rect,
@@ skipping 242 matching lines @@
 ResourceProvider::ResourceProvider(OutputSurface* output_surface)
     : output_surface_(output_surface),
       lost_output_surface_(false),
       next_id_(1),
       next_child_(1),
       default_resource_type_(output_surface->context3d() ? GLTexture : Bitmap),
       use_texture_storage_ext_(false),
       use_texture_usage_hint_(false),
       use_shallow_flush_(false),
       max_texture_size_(0),
-      best_texture_format_(0) {}
+      best_texture_format_(0),
+      use_gpu_memory_buffers_(false) {
+}
 
 bool ResourceProvider::Initialize(int highp_threshold_min) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d) {
     max_texture_size_ = INT_MAX / 2;
     best_texture_format_ = GL_RGBA;
     return true;
   }
   if (!context3d->makeContextCurrent())
@@ skipping 207 matching lines @@
                                         TransferableResource* resource) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* source = &it->second;
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(!source->external || (source->external && !source->mailbox.IsEmpty()));
   DCHECK(source->allocated);
+  DCHECK(!source->image_id);
   if (source->exported)
     return false;
   resource->id = id;
   resource->format = source->format;
   resource->filter = source->filter;
   resource->size = source->size;
 
   if (source->mailbox.IsEmpty()) {
     GLC(context3d, context3d->genMailboxCHROMIUM(resource->mailbox.name));
     source->mailbox.SetName(resource->mailbox);
@@ skipping 16 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    if (!resource->gl_pixel_buffer_id)
-      resource->gl_pixel_buffer_id = context3d->createBuffer();
-    context3d->bindBuffer(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->gl_pixel_buffer_id);
-    context3d->bufferData(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->size.width() * resource->size.height() * 4,
-        NULL,
-        GL_DYNAMIC_DRAW);
-    context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    if (!use_gpu_memory_buffers_) {
+      if (!resource->gl_pixel_buffer_id)
+        resource->gl_pixel_buffer_id = context3d->createBuffer();
+      context3d->bindBuffer(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->gl_pixel_buffer_id);
+      context3d->bufferData(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->size.width() * resource->size.height() * 4,
+          NULL,
+          GL_DYNAMIC_DRAW);
+      context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    } else {
+      DCHECK_EQ(0u, resource->image_id);
+      resource->image_id = context3d->createImageCHROMIUM(
+          resource->size.width(), resource->size.height(), GL_RGBA8_OES);

[reveman, 2013/05/17 01:48:08]

please put this in a new AcquireImage() function instead.

[kaanb, 2013/05/17 21:27:36]

Done.

+    }
   }
 
   if (resource->pixels) {
     if (resource->pixel_buffer)
       return;
 
     resource->pixel_buffer = new uint8_t[
         resource->size.width() * resource->size.height() * 4];
   }
 }
 
 void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
 
   if (resource->gl_id) {
-    if (!resource->gl_pixel_buffer_id)
+    if (!resource->gl_pixel_buffer_id && resource->image_id == 0)
       return;
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    context3d->bindBuffer(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->gl_pixel_buffer_id);
-    context3d->bufferData(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        0,
-        NULL,
-        GL_DYNAMIC_DRAW);
-    context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    if (resource->image_id == 0) {
+      DCHECK(resource->gl_pixel_buffer_id);
+      context3d->bindBuffer(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->gl_pixel_buffer_id);
+      context3d->bufferData(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          0,
+          NULL,
+          GL_DYNAMIC_DRAW);
+      context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    } else {
+      context3d->destroyImageCHROMIUM(resource->image_id);
+      resource->image_id = 0;

[reveman, 2013/05/17 01:48:08]

and this in ReleaseImage()

[kaanb, 2013/05/17 21:27:36]

Done.

+    }
   }
 
   if (resource->pixels) {
     if (!resource->pixel_buffer)
       return;
     delete[] resource->pixel_buffer;
     resource->pixel_buffer = NULL;
   }
 }
 
 uint8_t* ResourceProvider::MapPixelBuffer(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    DCHECK(resource->gl_pixel_buffer_id);
-    context3d->bindBuffer(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->gl_pixel_buffer_id);
-    uint8_t* image = static_cast<uint8_t*>(
-        context3d->mapBufferCHROMIUM(
-            GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
-    context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-    return image;
+    if (resource->image_id == 0) {
+      DCHECK(resource->gl_pixel_buffer_id);
+      context3d->bindBuffer(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->gl_pixel_buffer_id);
+      uint8_t* image = static_cast<uint8_t*>(
+          context3d->mapBufferCHROMIUM(
+              GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
+      context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+      return image;
+    } else {
+      return static_cast<uint8_t*>(
+          context3d->mapImageCHROMIUM(resource->image_id, GL_READ_WRITE));

[reveman, 2013/05/17 01:48:08]

and I prefer this in a MapImage() function. We might want to expose
GL_READ_WRITE as a parameter in the future but this initial patch doesn't need
to do that.

[kaanb, 2013/05/17 21:27:36]

Done.

+    }
   }
 
   if (resource->pixels)
     return resource->pixel_buffer;
 
   return NULL;
 }
 
 void ResourceProvider::UnmapPixelBuffer(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    DCHECK(resource->gl_pixel_buffer_id);
-    context3d->bindBuffer(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->gl_pixel_buffer_id);
-    context3d->unmapBufferCHROMIUM(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
-    context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    if (resource->image_id == 0) {
+      DCHECK(resource->gl_pixel_buffer_id);
+      context3d->bindBuffer(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->gl_pixel_buffer_id);
+      context3d->unmapBufferCHROMIUM(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
+      context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    } else {
+      context3d->unmapImageCHROMIUM(resource->image_id);

[reveman, 2013/05/17 01:48:08]

UnmapImage.

[kaanb, 2013/05/17 21:27:36]

Done.

+    }
   }
 }
 
 void ResourceProvider::SetPixelsFromBuffer(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->external);
   DCHECK(!resource->exported);
   DCHECK(ReadLockFenceHasPassed(resource));
+  DCHECK(!resource->image_id);

[reveman, 2013/05/17 01:48:08]

I don't think this DCHECK should be here.

[kaanb, 2013/05/17 21:27:36]

Done.

   LazyAllocate(resource);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_pixel_buffer_id);
     context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
@@ skipping 53 matching lines @@
   DCHECK(resource->gl_id || resource->allocated);
   DCHECK(ReadLockFenceHasPassed(resource));
 
   bool allocate = !resource->allocated;
   resource->allocated = true;
   LockForWrite(id);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    DCHECK(resource->gl_pixel_buffer_id);
-    context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
-    context3d->bindBuffer(
-        GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        resource->gl_pixel_buffer_id);
-    if (!resource->gl_upload_query_id)
-      resource->gl_upload_query_id = context3d->createQueryEXT();
-    context3d->beginQueryEXT(
-        GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
-        resource->gl_upload_query_id);
-    if (allocate) {
-      context3d->asyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
-                                         0, /* level */
-                                         resource->format,
-                                         resource->size.width(),
-                                         resource->size.height(),
-                                         0, /* border */
-                                         resource->format,
-                                         GL_UNSIGNED_BYTE,
-                                         NULL);
+    if (resource->image_id == 0) {
+      DCHECK(resource->gl_pixel_buffer_id);
+      context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
+      context3d->bindBuffer(
+          GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
+          resource->gl_pixel_buffer_id);
+      if (!resource->gl_upload_query_id)
+        resource->gl_upload_query_id = context3d->createQueryEXT();
+      context3d->beginQueryEXT(
+          GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
+          resource->gl_upload_query_id);
+      if (allocate) {
+        context3d->asyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
+                                           0, /* level */
+                                           resource->format,
+                                           resource->size.width(),
+                                           resource->size.height(),
+                                           0, /* border */
+                                           resource->format,
+                                           GL_UNSIGNED_BYTE,
+                                           NULL);
+      } else {
+        context3d->asyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
+                                              0, /* level */
+                                              0, /* x */
+                                              0, /* y */
+                                              resource->size.width(),
+                                              resource->size.height(),
+                                              resource->format,
+                                              GL_UNSIGNED_BYTE,
+                                              NULL);
+      }
+      context3d->endQueryEXT(GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM);
+      context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
     } else {
-      context3d->asyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
-                                            0, /* level */
-                                            0, /* x */
-                                            0, /* y */
-                                            resource->size.width(),
-                                            resource->size.height(),
-                                            resource->format,
-                                            GL_UNSIGNED_BYTE,
-                                            NULL);
+      context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
+      context3d->bindTexImage2DCHROMIUM(GL_TEXTURE_2D, resource->image_id);

[reveman, 2013/05/17 01:48:08]

please add a BindImage() function for this instead.

[kaanb, 2013/05/17 21:27:36]

Done.

     }
-    context3d->endQueryEXT(GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM);
-    context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels)
     SetPixelsFromBuffer(id);
 
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
   DCHECK(!resource->set_pixels_completion_forced);
 
-  if (resource->gl_id) {
+  if (resource->gl_id && resource->image_id == 0) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
     GLC(context3d, context3d->waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, 0));
   }
 
   resource->set_pixels_completion_forced = true;
 }
 
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
 
-  if (resource->gl_id) {
+  if (resource->gl_id && resource->image_id == 0) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_upload_query_id);
     unsigned complete = 1;
     context3d->getQueryObjectuivEXT(
         resource->gl_upload_query_id,
         GL_QUERY_RESULT_AVAILABLE_EXT,
         &complete);
     if (!complete)
       return false;
   }
 
   resource->pending_set_pixels = false;
   UnlockForWrite(id);
 
   return true;
 }
 
 void ResourceProvider::AbortSetPixels(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
-    DCHECK(resource->gl_upload_query_id);
-    // CHROMIUM_async_pixel_transfers currently doesn't have a way to
-    // abort an upload. The best we can do is delete the query and
-    // the texture.
-    context3d->deleteQueryEXT(resource->gl_upload_query_id);
-    resource->gl_upload_query_id = 0;
+    if (resource->image_id == 0) {
+      DCHECK(resource->gl_upload_query_id);
+      // CHROMIUM_async_pixel_transfers currently doesn't have a way to
+      // abort an upload. The best we can do is delete the query and
+      // the texture.
+      context3d->deleteQueryEXT(resource->gl_upload_query_id);
+      resource->gl_upload_query_id = 0;
+    } else {
+      // CHROMIUM_map_image doesn't have a way to abort an upload either.
+      // So we just destroy the image.
+      DCHECK(resource->image_id);
+      context3d->destroyImageCHROMIUM(resource->image_id);
+      resource->image_id = 0;

[reveman, 2013/05/17 01:48:08]

no need for any of these changes.

[kaanb, 2013/05/17 21:27:36]

Done.

+    }
     context3d->deleteTexture(resource->gl_id);
     resource->gl_id = CreateTextureId(context3d);
     resource->allocated = false;
   }
 
   resource->pending_set_pixels = false;
   UnlockForWrite(id);
 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   LazyAllocate(resource);
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   DCHECK(resource->gl_id || resource->allocated);
 
   if (resource->allocated || !resource->gl_id)
     return;
   resource->allocated = true;
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   gfx::Size& size = resource->size;
   GLenum format = resource->format;
+
   GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
   if (use_texture_storage_ext_ && IsTextureFormatSupportedForStorage(format)) {
     GLenum storage_format = TextureToStorageFormat(format);
     GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D,
                                               1,
                                               storage_format,
                                               size.width(),
                                               size.height()));
   } else {
+    // TODO(kaanb): Check with reviewers if we want this call
+    // for GpuMemoryBuffers?

[reveman, 2013/05/17 01:48:08]

I don't think this affects zero-copy. just like it doesn't affect async uploads.

[kaanb, 2013/05/17 21:27:36]

Acknowledged.

     GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D,
                                          0,
                                          format,
                                          size.width(),
                                          size.height(),
                                          0,
                                          format,
                                          GL_UNSIGNED_BYTE,
                                          NULL));
   }
 }
 
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   resource->enable_read_lock_fences = enable;
 }
 
+void ResourceProvider::SetUseGpuMemoryBuffers(bool use_gpu_memory_buffers) {
+  use_gpu_memory_buffers_ = use_gpu_memory_buffers;
+}
+
 }  // namespace cc