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..94cb3d3abc91e7016598b957f9c1f5af324152a3 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_));

[reveman, 2015/07/10 13:50:34]

How does is this supposed to work? We have to create a fence for the context
that we used to perform the copy operation and not the cc thread. We also want
to use these fences to block on the worker context.

I think we need to create the query for the worker context on the worker thread
as part of issuing the copy command. This also means that you can't use the
"busy" login in the resource pool to check for completion.

I'm wondering if it wouldn't be much easier to avoid using the ResourcePool
class and ResourceProvider for staging resources all together and just manage
staging resources inside the OneCopyTileTaskWorkerPool.

[piman, 2015/07/10 17:12:36]

The query is created on the worker context around the copy (see
BeginCopyTexture/EndCopyTexture), but you're right that we need to use the
worker context here rather than the compositor context, but causes further
problems since queries are not shared across contexts.
I think that's a really reasonable approach.

+  } 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 = false;
+    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.