cc: Remove 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 894 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,
-    bool create_gpu_memory_buffer) {
+const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
   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 44 matching lines @@
 void ResourceProvider::EnableReadLockFencesForTesting(ResourceId id) {
   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) {
-  const Resource* resource = resource_provider->LockForRead(resource_id, false);
+  const Resource* resource = resource_provider->LockForRead(resource_id);
   texture_id_ = resource->gl_id;
   target_ = resource->target;
   size_ = resource->size;
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
@@ skipping 116 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, false);
+  const Resource* resource = resource_provider->LockForRead(resource_id);
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
 }
 
 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
@@ skipping 51 matching lines @@
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
   if (!gpu_memory_buffer_) {
     gpu_memory_buffer_ =
         resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
             size_, BufferFormat(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) {
-  const Resource* resource = resource_provider->LockForRead(resource_id, true);
-  gpu_memory_buffer_ = resource->gpu_memory_buffer.get();
-  texture_id_ = resource->gl_id;
-}
-
-ResourceProvider::ScopedReadLockGpuMemoryBuffer::
-    ~ScopedReadLockGpuMemoryBuffer() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  resource_provider_->UnlockForRead(resource_id_);
-}
-
 ResourceProvider::SynchronousFence::SynchronousFence(
     gpu::gles2::GLES2Interface* gl)
     : gl_(gl), has_synchronized_(true) {
 }
 
 ResourceProvider::SynchronousFence::~SynchronousFence() {
 }
 
 void ResourceProvider::SynchronousFence::Set() {
   has_synchronized_ = false;
@@ skipping 716 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc