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 <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "cc/resources/platform_color.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/scheduler/texture_uploader.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/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"
+#include "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 static GLenum TextureToStorageFormat(GLenum texture_format) {
   GLenum storage_format = GL_RGBA8_OES;
   switch (texture_format) {
     case GL_RGBA:
       break;
@@ skipping 39 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),
-      type(static_cast<ResourceType>(0)) {}
+      type(static_cast<ResourceType>(0)),
+      use_gpu_memory_buffer(false) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
-    unsigned texture_id, gfx::Size size, GLenum format, GLenum filter)
+    unsigned texture_id, gfx::Size size,
+    GLenum format, GLenum filter, bool gpu_memory_buffer)
     : 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),
-      type(GLTexture) {}
+      type(GLTexture),
+      use_gpu_memory_buffer(gpu_memory_buffer) {}
 
 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),
-      type(Bitmap) {}
+      type(Bitmap),
+      use_gpu_memory_buffer(false) {}
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     int highp_threshold_min) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface));
@@ skipping 70 matching lines @@
   GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                           GL_TEXTURE_POOL_CHROMIUM,
                                           texture_pool));
   if (use_texture_usage_hint_ && hint == TextureUsageFramebuffer) {
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                             GL_TEXTURE_USAGE_ANGLE,
                                             GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
   }
 
   ResourceId id = next_id_++;
-  Resource resource(texture_id, size, format, GL_LINEAR);
+  Resource resource(texture_id, size, format, GL_LINEAR,
+      use_gpu_memory_buffers_);
   resource.allocated = false;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateBitmap(gfx::Size size) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
 
@@ skipping 16 matching lines @@
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
   ResourceId id = next_id_++;
-  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR);
+  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, false);
   resource.external = true;
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   unsigned texture_id = 0;
-  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR);
+  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, false);
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
   resources_[id] = resource;
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
@@ skipping 73 matching lines @@
                                  gfx::Rect source_rect,
                                  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(!resource->use_gpu_memory_buffer);
   DCHECK(ReadLockFenceHasPassed(resource));
   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,
@@ skipping 233 matching lines @@
 ResourceProvider::ResourceProvider(OutputSurface* output_surface)
     : output_surface_(output_surface),
       lost_output_surface_(false),
       next_id_(1),
       next_child_(1),
       default_resource_type_(GLTexture),
       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 151 matching lines @@
     // 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());
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D,
                                                      it->mailbox.name));
     ResourceId id = next_id_++;
-    Resource resource(texture_id, it->size, it->format, it->filter);
+    Resource resource(texture_id, it->size, it->format, it->filter, false);
     resource.mailbox.SetName(it->mailbox);
     // Don't allocate a texture for a child.
     resource.allocated = true;
     resources_[id] = resource;
     child_info.parent_to_child_map[id] = it->id;
     child_info.child_to_parent_map[it->id] = id;
   }
 }
 
 void ResourceProvider::ReceiveFromParent(
@@ skipping 73 matching lines @@
   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);
+    WGC3Denum target = GetTargetGivenResource(resource);
+    context3d->bindBuffer(target, resource->gl_pixel_buffer_id);
+    if (resource->use_gpu_memory_buffer) {
+      typedef webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl
+          Context3DImpl;
+      Context3DImpl* in_process_context =
+          static_cast<Context3DImpl*>(context3d);

[jamesr, 2013/04/25 22:28:56]

you shouldn't be downcasting like this. it means that the use_gpu_memory_buffer
setting will cause crashes for anyone using a different context type. why isn't
this on the context API itself with an appropriate fallback behavior for when
the extension isn't supported?

[kaanb1, 2013/04/25 22:43:29]

This feature is currently only used for Android WebView which is hardwired to
use this context type so the downcast would be safe. I thought it would be a
reasonable compromise to move it to the interface API after other people start
using this code. If you disagree, let me know and I'll prepare a blink patch.

[no sievers, 2013/04/25 23:28:14]

Keep in mind that ChromeOS might implement 0-copy uploads too. And so could any
other platforms. If you properly expose it, it will be likelier that this gets
shared like it should.

[kaanb1, 2013/04/25 23:55:05]

Done.

+      in_process_context->imageBufferDataCHROMIUM(
+          target,
+          resource->size.width(),
+          resource->size.height());
+    } else {
+      context3d->bufferData(
+          target,
+          resource->size.width() * resource->size.height() * 4,
+          NULL,
+          GL_DYNAMIC_DRAW);
+    }
+    context3d->bindBuffer(target, 0);
   }
 
   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) {
     DCHECK(resource->gl_pixel_buffer_id);
     WebGraphicsContext3D* context3d = output_surface_->context3d();
+    WGC3Denum target = GetTargetGivenResource(resource);
     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);
+    context3d->bindBuffer(target, resource->gl_pixel_buffer_id);
+    if (resource->use_gpu_memory_buffer) {
+      typedef webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl
+          Context3DImpl;
+      Context3DImpl* in_process_context =
+          static_cast<Context3DImpl*>(context3d);
+      in_process_context->imageBufferDataCHROMIUM(target, 0, 0);
+    } else {
+      context3d->bufferData(target, 0, NULL, GL_DYNAMIC_DRAW);
+    }
+    context3d->bindBuffer(target, 0);
   }
 
   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);
+    WGC3Denum target = GetTargetGivenResource(resource);
+    context3d->bindBuffer(target, 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);
+        context3d->mapBufferCHROMIUM(target, GL_WRITE_ONLY));
+    context3d->bindBuffer(target, 0);
     DCHECK(image);
     return image;
   }
 
   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);
+    WGC3Denum target = GetTargetGivenResource(resource);
+    context3d->bindBuffer(target, resource->gl_pixel_buffer_id);
+    context3d->unmapBufferCHROMIUM(target);
+    context3d->bindBuffer(target, 0);
   }
 }
 
 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->use_gpu_memory_buffer);
   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 57 matching lines @@
 
   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->use_gpu_memory_buffer) {
+      context3d->bindTexImage2DCHROMIUM(
+          GL_TEXTURE_2D, resource->gl_pixel_buffer_id);
     } 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->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);
     }
-    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);
+  DCHECK(!resource->use_gpu_memory_buffer);
 
   if (resource->gl_id) {
     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);
+  DCHECK(!resource->use_gpu_memory_buffer);
 
   if (resource->gl_id) {
     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);
+  DCHECK(!resource->use_gpu_memory_buffer);
 
   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;
@@ skipping 46 matching lines @@
 
 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;
+}
+
+GLenum ResourceProvider::GetTargetGivenResource(Resource* resource) {
+    return resource->use_gpu_memory_buffer
+        ? GL_IMAGE_BUFFER_CHROMIUM
+        : GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM;
+}
+
 }  // namespace cc