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

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 11 matching lines @@
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #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;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
 
   virtual GLuint NextId() = 0;
@@ skipping 944 matching lines @@
       resource_provider_->use_persistent_map_for_gpu_memory_buffers()
           ? gfx::GpuMemoryBuffer::PERSISTENT_MAP
           : gfx::GpuMemoryBuffer::MAP;
   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_;
 }
 
+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)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->LazyAllocate(resource_);
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
@@ skipping 865 matching lines @@
                       source_resource->gl_read_lock_query_id);
 #else
     gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
 #endif
   }
   DCHECK(!dest_resource->image_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.
 #if defined(OS_CHROMEOS)
     gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
 #else
     gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
 #endif
     source_resource->read_lock_fence = make_scoped_refptr(
         new CopyTextureFence(gl, source_resource->gl_read_lock_query_id));
@@ skipping 51 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc