cc: [WIP] Use worker context and OrderingBarrierCHROMIUM for one-copy.

cc/resources/resource_provider.cc

Index: cc/resources/resource_provider.cc
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index f081f6236f87a36410537af4a9c0e570f1191510..f529196aca98714e8201676bb5246988edbed13d 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -29,7 +29,6 @@
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 
 using gpu::gles2::GLES2Interface;
 
@@ -994,6 +993,124 @@ ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
   return gpu_memory_buffer_;
 }
 
+ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    ScopedWriteLockGpuMemoryBufferForThread(ResourceProvider* resource_provider,
+                                            ResourceId resource_id)
+    : resource_provider_(resource_provider),
+      resource_(resource_provider_->GetResource(resource_id)),
+      gpu_memory_buffer_manager_(resource_provider->gpu_memory_buffer_manager_),
+      gpu_memory_buffer_(nullptr),
+      size_(resource_->size),
+      format_(resource_->format) {
+  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource_->type);
+  resource_provider_->LazyCreate(resource_);
+  worker_context_ =
+      resource_provider_->output_surface()->worker_context_provider();
+  image_id_ = resource_->image_id;
+  did_bind_image_ = false;
+  internal_format_ = GLInternalFormat(resource_->format);
+  source_gl_id_ = resource_->gl_id;
+  query_id_ = resource_->gl_read_lock_query_id;
+  using_sync_query_ = resource_provider_->use_sync_query_;
+
+  usage_ = resource_provider_->use_persistent_map_for_gpu_memory_buffers()
+               ? gfx::GpuMemoryBuffer::PERSISTENT_MAP
+               : gfx::GpuMemoryBuffer::MAP;
+  std::swap(gpu_memory_buffer_, resource_->gpu_memory_buffer);
+}
+
+ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    ~ScopedWriteLockGpuMemoryBufferForThread() {
+  GLES2Interface* gl =
+      resource_provider_->output_surface()->context_provider()->ContextGL();
+  if (!gpu_memory_buffer_)
+    return;
+
+  if (using_sync_query_ && query_id_) {
+    resource_->gl_read_lock_query_id = query_id_;
+    resource_->read_lock_fence =
+        make_scoped_refptr(new CopyTextureFence(gl, query_id_));
+  } else {
+    // Create a SynchronousFence when CHROMIUM_sync_query extension is missing.
+    // Try to use one synchronous fence for as many CopyResource operations as
+    // possible as that reduce the number of times we have to synchronize with
+    // the GL.
+    if (!resource_provider_->synchronous_fence_.get() ||
+        resource_provider_->synchronous_fence_->has_synchronized()) {
+      resource_provider_->synchronous_fence_ =
+          make_scoped_refptr(new SynchronousFence(gl));
+    }
+    resource_->read_lock_fence = resource_provider_->synchronous_fence_;
+    resource_->read_lock_fence->Set();
+  }
+
+  std::swap(resource_->gpu_memory_buffer, gpu_memory_buffer_);
+  if (did_bind_image_) {
+    resource_->image_id = image_id_;
+    resource_->allocated = true;
+    resource_->dirty_image = true;

[piman, 2015/07/10 02:25:09]

= false

[sohanjg, 2015/07/10 13:34:31]

Acknowledged.

+    resource_->bound_image_id = bound_image_id_;
+    resource_->read_lock_fences_enabled = true;
+  }
+}
+
+gfx::GpuMemoryBuffer* ResourceProvider::
+    ScopedWriteLockGpuMemoryBufferForThread::GetGpuMemoryBuffer() {
+  if (gpu_memory_buffer_)
+    return gpu_memory_buffer_;
+  scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
+      gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
+          size_, ToGpuMemoryBufferFormat(format_), usage_);
+  gpu_memory_buffer_ = gpu_memory_buffer.release();
+  return gpu_memory_buffer_;
+}
+
+void ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    CreateAndBindImage() {
+  GLES2Interface* gl = worker_context_->ContextGL();
+  image_id_ =
+      gl->CreateImageCHROMIUM(gpu_memory_buffer_->AsClientBuffer(),
+                              size_.width(), size_.height(), internal_format_);
+
+  gl->BindTexture(GL_TEXTURE_2D, source_gl_id_);
+  if (bound_image_id_)
+    gl->ReleaseTexImage2DCHROMIUM(GL_TEXTURE_2D, bound_image_id_);
+  gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id_);
+  bound_image_id_ = image_id_;
+  did_bind_image_ = true;
+}
+
+void ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    BeginCopyTexture() {
+  GLES2Interface* gl = worker_context_->ContextGL();
+  if (using_sync_query_) {
+    if (!query_id_)
+      gl->GenQueriesEXT(1, &query_id_);
+#if defined(OS_CHROMEOS)
+    // TODO(reveman): This avoids a performance problem on some ChromeOS
+    // devices. This needs to be removed to support native GpuMemoryBuffer
+    // implementations. crbug.com/436314
+    gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, query_id_);
+#else
+    gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, query_id_);
+#endif
+  }
+}
+
+void ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    EndCopyTexture() {
+  GLES2Interface* gl = worker_context_->ContextGL();
+  if (using_sync_query_ && query_id_) {
+// End query and create a read lock fence that will prevent access to
+// source resource until CopySubTextureCHROMIUM command has completed.
+#if defined(OS_CHROMEOS)
+    gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
+#else
+    gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
+#endif
+  }
+}
+
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
@@ -1879,8 +1996,8 @@ void ResourceProvider::CopyResource(ResourceId source_id,
   dest_resource->allocated = true;
   gl->CopySubTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
                              dest_resource->gl_id, rect.x(), rect.y(), rect.x(),
-                             rect.y(), rect.width(), rect.height(),
-                             false, false, false);
+                             rect.y(), rect.width(), rect.height(), false,
+                             false, false);
   if (source_resource->gl_read_lock_query_id) {
     // End query and create a read lock fence that will prevent access to
 // source resource until CopySubTextureCHROMIUM command has completed.