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 976 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_ = 0;

[piman, 2015/07/01 22:11:05]

I think you want to initialize with resource_->image_id here, so that you reuse
the image if it was already created.

[sohanjg, 2015/07/02 14:40:28]

Done.

+  allocated_ = false;
+  dirty_image_ = false;
+  read_lock_fences_enabled_ = false;

[piman, 2015/07/01 22:11:05]

Same here for all 3, you may need to get the values from resource_.

[sohanjg, 2015/07/02 14:40:28]

Done.

+  internal_format_ = GLInternalFormat(resource_->format);
+  std::swap(gpu_memory_buffer_, resource_->gpu_memory_buffer);
+}
+
+ResourceProvider::ScopedWriteLockGpuMemoryBufferForThread::
+    ~ScopedWriteLockGpuMemoryBufferForThread() {
+  if (!gpu_memory_buffer_)
+    return;
+
+  if (!resource_->image_id) {

[piman, 2015/07/01 22:11:05]

you don't need / want this test any more if you initialize image_id_ with
resource_->image_id in the constructor.

[sohanjg, 2015/07/02 14:40:28]

Done.

+    resource_->image_id = image_id_;
+  }
+
+  std::swap(resource_->gpu_memory_buffer, gpu_memory_buffer_);
+  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_;
+  gfx::GpuMemoryBuffer::Usage usage =
+      resource_provider_->use_persistent_map_for_gpu_memory_buffers()

[piman, 2015/07/01 22:11:05]

If this is called on the worker thread, it's not safe to call into
resource_provider_. You probably want to figure out the usage value in the
constructor.

[sohanjg, 2015/07/02 14:40:28]

Done.

+          ? 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::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