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,
+                                            unsigned dest_texture_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;
+  allocated_ = resource_->allocated;
+  dirty_image_ = resource_->dirty_image;
+  read_lock_fences_enabled_ = resource_->read_lock_fences_enabled;
+  did_bind_image_ = false;
+  internal_format_ = GLInternalFormat(resource_->format);
+  source_gl_id_ = resource_->gl_id;
+  dest_gl_id_ = dest_texture_id;

[piman, 2015/07/08 23:12:13]

I don't think this belongs to the ScopedWriteLockGpuMemoryBufferForThread, it's
not used at all in this class. Instead, you should keep around the
ScopedWriteLockGL in the RasterBufferImpl (see comments there too) and get the
texture id from it.

[sohanjg, 2015/07/09 10:04:56]

Done.

+  if (resource_provider_->use_sync_query_) {
+    query_id_ = 0;

[piman, 2015/07/08 23:12:13]

nit: always initialize all fields (i.e. you want to initialize query_id_ even if
!resource_provider_->use_sync_query_)

here, I think we want to reuse the query from a previous copy to the same
texture, i.e. we should take resource_->gl_read_lock_query_id, and store it back
in the destructor.

[sohanjg, 2015/07/09 10:04:56]

Done.

+    using_sync_query_ = true;

[piman, 2015/07/08 23:12:13]

In particular, this one needs to be initialized to false in the
!resource_provider_->use_sync_query_ case.

So how about always initializing:
query_id_ = resource_->gl_read_lock_query_id;
using_sync_query_ = resource_provider_->use_sync_query_;

[sohanjg, 2015/07/09 10:04:56]

Done.

+  }
+  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_->read_lock_fence =
+        make_scoped_refptr(new CopyTextureFence(gl, query_id_));

[piman, 2015/07/08 23:12:13]

As mentioned above, you need to save the query for later reuse:
resource_->gl_read_lock_query_id = query_id_

[sohanjg, 2015/07/09 10:04:56]

Done.

+  } 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())

[piman, 2015/07/08 23:12:13]

nit: needs {} per style guide

[sohanjg, 2015/07/09 10:04:56]

Done.

+      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 = allocated_;
+    resource_->dirty_image = dirty_image_;
+    resource_->bound_image_id = bound_image_id_;
+
+    resource_->read_lock_fences_enabled = read_lock_fences_enabled_;
+  }
+}
+
+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_);
+
+  allocated_ = true;
+  read_lock_fences_enabled_ = true;

[piman, 2015/07/08 23:12:13]

You don't need those 2 as a field, you can just set them to true on the resource
in the if (did_bind_image_) block in the destructor (l.1054/1058).

[sohanjg, 2015/07/09 10:04:56]

Done.

+  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_;
+  dirty_image_ = false;

[piman, 2015/07/08 23:12:13]

Same for this, don't need it as a field, you can just set to false on the
resource on l.1055.

[sohanjg, 2015/07/09 10:04:56]

Done.

+  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