cc: Add ScopedReadLockGpuMemoryBuffer

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 357 matching lines @@
 
   // In the case of context lost, this sync token may be empty (see comment in
   // the UpdateSyncToken() function). The WaitSyncTokenCHROMIUM() function
   // handles empty sync tokens properly so just wait anyways and update the
   // state the synchronized.
   gl->WaitSyncTokenCHROMIUM(mailbox_.sync_token().GetConstData());
   SetSynchronized();
 }
 
 ResourceProvider::Child::Child()
-    : marked_for_deletion(false), needs_sync_tokens(true) {}
+    : gpu_memory_buffer_client_id(-1),
+      marked_for_deletion(false),
+      needs_sync_tokens(true) {}
 
 ResourceProvider::Child::Child(const Child& other) = default;
 
 ResourceProvider::Child::~Child() {}
 
 std::unique_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
@@ skipping 325 matching lines @@
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = nullptr;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::INTERNAL);
     delete[] resource->pixels;
     resource->pixels = nullptr;
   }
   if (resource->gpu_memory_buffer) {
-    DCHECK(resource->origin == Resource::INTERNAL);
+    DCHECK(resource->origin == Resource::INTERNAL ||
+           resource->origin == Resource::DELEGATED);
     resource->gpu_memory_buffer.reset();
   }
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
 
@@ skipping 97 matching lines @@
 }
 
 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id);
   ResourceMap::iterator it = resources_.find(id);
   DCHECK(it != resources_.end());
   return &it->second;
 }
 
-const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
+const ResourceProvider::Resource* ResourceProvider::LockForRead(
+    ResourceId id,
+    bool create_gpu_memory_buffer) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write) << "locked for write: "
                                       << resource->locked_for_write;
   DCHECK_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
   // Mailbox sync_tokens must be processed by a call to
   // WaitSyncTokenIfNeeded() prior to calling LockForRead().
   DCHECK_NE(Resource::NEEDS_WAIT, resource->synchronization_state());
@@ skipping 22 matching lines @@
     }
   }
 
   resource->lock_for_read_count++;
   if (resource->read_lock_fences_enabled) {
     if (current_read_lock_fence_.get())
       current_read_lock_fence_->Set();
     resource->read_lock_fence = current_read_lock_fence_;
   }
 
+  if (create_gpu_memory_buffer && !resource->gpu_memory_buffer &&
+      resource->child_id) {
+    ChildMap::iterator child_it = children_.find(resource->child_id);
+    DCHECK(child_it != children_.end());
+    Child& child_info = child_it->second;
+    if (child_info.gpu_memory_buffer_client_id != -1 &&
+        resource->gpu_memory_buffer_id.id != -1) {
+      resource->gpu_memory_buffer =
+          gpu_memory_buffer_manager_->CreateGpuMemoryBufferFromClientId(
+              child_info.gpu_memory_buffer_client_id,
+              resource->gpu_memory_buffer_id);
+    }
+  }
+
   return resource;
 }
 
 void ResourceProvider::UnlockForRead(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
 
   Resource* resource = &it->second;
   DCHECK_GT(resource->lock_for_read_count, 0);
@@ skipping 56 matching lines @@
   Resource* resource = GetResource(id);
   DCHECK(resource);
   resource->read_lock_fences_enabled = true;
 }
 
 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
-      resource_(resource_provider->LockForRead(resource_id)) {
+      resource_(resource_provider->LockForRead(resource_id, false)) {
   DCHECK(resource_);
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     ResourceProvider* resource_provider,
     ResourceId resource_id,
@@ skipping 41 matching lines @@
   DCHECK_EQ(RGBA_8888, resource->format);
   SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
                                                 resource->size.height());
   sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
 }
 
 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
-  const Resource* resource = resource_provider->LockForRead(resource_id);
+  const Resource* resource = resource_provider->LockForRead(resource_id, false);
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
 }
 
 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
@@ skipping 46 matching lines @@
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
   if (!gpu_memory_buffer_) {
     gpu_memory_buffer_ =
         resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
             resource_->size, BufferFormat(resource_->format),
             gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle);
   }
   return gpu_memory_buffer_.get();
 }
 
+ResourceProvider::ScopedReadLockGpuMemoryBuffer::ScopedReadLockGpuMemoryBuffer(
+    ResourceProvider* resource_provider,
+    ResourceId resource_id)
+    : resource_provider_(resource_provider),
+      resource_id_(resource_id),
+      resource_(resource_provider->LockForRead(resource_id, true)) {}
+
+ResourceProvider::ScopedReadLockGpuMemoryBuffer::
+    ~ScopedReadLockGpuMemoryBuffer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  resource_provider_->UnlockForRead(resource_id_);
+}
+
+gfx::GpuMemoryBuffer*
+ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetGpuMemoryBuffer() const {
+  return resource_->gpu_memory_buffer.get();
+}
+
+unsigned ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetTextureId() const {
+  return resource_->gl_id;
+}
+
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)),
       set_sync_token_(false) {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->LazyAllocate(resource_);
   if (resource_->image_id && resource_->dirty_image)
     resource_provider_->BindImageForSampling(resource_);
@@ skipping 157 matching lines @@
 
   best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
       caps.render_buffer_format_bgra8888);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
 
-int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
+int ResourceProvider::CreateChild(const ReturnCallback& return_callback,
+                                  int gpu_memory_buffer_client_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
+  child_info.gpu_memory_buffer_client_id = gpu_memory_buffer_client_id;
 
   int child = next_child_++;
   children_[child] = child_info;
   return child;
 }
 
 void ResourceProvider::SetChildNeedsSyncTokens(int child_id, bool needs) {
   ChildMap::iterator it = children_.find(child_id);
   DCHECK(it != children_.end());
   it->second.needs_sync_tokens = needs;
@@ skipping 686 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc