Update from chromium https://crrev.com/301725/

cc/resources/resource_provider.cc

Index: cc/resources/resource_provider.cc
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index a37789a94d3ba60da59223c1420b928f56208adc..14f4880810cdc8e79893f4be89b07443283fce96 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -14,7 +14,6 @@
 #include "base/strings/string_util.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
-#include "cc/resources/gpu_memory_buffer_manager.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
@@ -22,6 +21,7 @@
 #include "cc/resources/transferable_resource.h"
 #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"
@@ -407,7 +407,7 @@ ResourceProvider::Child::~Child() {}
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
-    GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
@@ -922,11 +922,9 @@ void ResourceProvider::UnlockForRead(ResourceId id) {
   }
 }
 
-const ResourceProvider::Resource* ResourceProvider::LockForWrite(
-    ResourceId id) {
+ResourceProvider::Resource* ResourceProvider::LockForWrite(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(CanLockForWrite(id));
-  LazyAllocate(resource);
 
   resource->locked_for_write = true;
   return resource;
@@ -939,77 +937,13 @@ bool ResourceProvider::CanLockForWrite(ResourceId id) {
          !resource->lost && ReadLockFenceHasPassed(resource);
 }
 
-void ResourceProvider::UnlockForWrite(ResourceId id) {
-  Resource* resource = GetResource(id);
+void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->origin == Resource::Internal);
   resource->locked_for_write = false;
 }
 
-const ResourceProvider::Resource*
-ResourceProvider::LockForWriteToGpuMemoryBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK_EQ(GLTexture, resource->type);
-  DCHECK(CanLockForWrite(id));
-
-  if (!resource->gpu_memory_buffer) {
-    scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
-        gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
-            resource->size,
-            ToGpuMemoryBufferFormat(resource->format),
-            gfx::GpuMemoryBuffer::MAP);
-    resource->gpu_memory_buffer = gpu_memory_buffer.release();
-    resource->allocated = true;
-  }
-
-  resource->locked_for_write = true;
-  return resource;
-}
-
-void ResourceProvider::UnlockForWriteToGpuMemoryBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK(resource->locked_for_write);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(resource->origin == Resource::Internal);
-  DCHECK_EQ(GLTexture, resource->type);
-
-  if (!resource->image_id) {
-    GLES2Interface* gl = ContextGL();
-    DCHECK(gl);
-    resource->image_id =
-        gl->CreateImageCHROMIUM(resource->gpu_memory_buffer->AsClientBuffer(),
-                                resource->size.width(),
-                                resource->size.height(),
-                                GL_RGBA);
-  }
-
-  resource->locked_for_write = false;
-  resource->dirty_image = true;
-
-  // GpuMemoryBuffer provides direct access to the memory used by the GPU.
-  // Read lock fences are required to ensure that we're not trying to map a
-  // buffer that is currently in-use by the GPU.
-  resource->read_lock_fences_enabled = true;
-}
-
-void ResourceProvider::LockForWriteToSkSurface(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK_EQ(GLTexture, resource->type);
-  DCHECK(CanLockForWrite(id));
-
-  resource->locked_for_write = true;
-}
-
-void ResourceProvider::UnlockForWriteToSkSurface(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK(resource->locked_for_write);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(resource->origin == Resource::Internal);
-  DCHECK_EQ(GLTexture, resource->type);
-  resource->locked_for_write = false;
-}
-
 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
@@ -1049,13 +983,14 @@ ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
-      resource_id_(resource_id),
-      texture_id_(resource_provider->LockForWrite(resource_id)->gl_id) {
+      resource_(resource_provider->LockForWrite(resource_id)) {
+  resource_provider_->LazyAllocate(resource_);
+  texture_id_ = resource_->gl_id;
   DCHECK(texture_id_);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
-  resource_provider_->UnlockForWrite(resource_id_);
+  resource_provider_->UnlockForWrite(resource_);
 }
 
 void ResourceProvider::PopulateSkBitmapWithResource(
@@ -1084,82 +1019,117 @@ ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
-      resource_id_(resource_id) {
-  ResourceProvider::PopulateSkBitmapWithResource(
-      &sk_bitmap_, resource_provider->LockForWrite(resource_id));
+      resource_(resource_provider->LockForWrite(resource_id)) {
+  ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource_);
   DCHECK(valid());
   sk_canvas_.reset(new SkCanvas(sk_bitmap_));
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
-  resource_provider_->UnlockForWrite(resource_id_);
+  resource_provider_->UnlockForWrite(resource_);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
-      resource_id_(resource_id),
-      gpu_memory_buffer_(
-          resource_provider->LockForWriteToGpuMemoryBuffer(resource_id)
-              ->gpu_memory_buffer) {
+      resource_(resource_provider->LockForWrite(resource_id)),
+      gpu_memory_buffer_manager_(resource_provider->gpu_memory_buffer_manager_),
+      gpu_memory_buffer_(nullptr),
+      size_(resource_->size),
+      format_(resource_->format) {
+  DCHECK_EQ(GLTexture, resource_->type);
+  std::swap(gpu_memory_buffer_, resource_->gpu_memory_buffer);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
-  resource_provider_->UnlockForWriteToGpuMemoryBuffer(resource_id_);
+  resource_provider_->UnlockForWrite(resource_);
+  if (!gpu_memory_buffer_)
+    return;
+
+  if (!resource_->image_id) {
+    GLES2Interface* gl = resource_provider_->ContextGL();
+    DCHECK(gl);
+
+    resource_->image_id =
+        gl->CreateImageCHROMIUM(gpu_memory_buffer_->AsClientBuffer(),
+                                size_.width(),
+                                size_.height(),
+                                GL_RGBA);
+  }
+
+  std::swap(resource_->gpu_memory_buffer, gpu_memory_buffer_);
+  resource_->allocated = true;
+  resource_->dirty_image = true;
+
+  // GpuMemoryBuffer provides direct access to the memory used by the GPU.
+  // Read lock fences are required to ensure that we're not trying to map a
+  // buffer that is currently in-use by the GPU.
+  resource_->read_lock_fences_enabled = true;
+}
+
+gfx::GpuMemoryBuffer*
+ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
+  if (!gpu_memory_buffer_) {
+    scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
+        gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
+            size_, ToGpuMemoryBufferFormat(format_), gfx::GpuMemoryBuffer::MAP);
+    gpu_memory_buffer_ = gpu_memory_buffer.release();
+  }
+
+  return gpu_memory_buffer_;
 }
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
-    : resource_provider_(resource_provider), resource_id_(resource_id) {
-  resource_provider->LockForWriteToSkSurface(resource_id);
+    : resource_provider_(resource_provider),
+      resource_(resource_provider->LockForWrite(resource_id)) {
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
-  resource_provider_->UnlockForWriteToSkSurface(resource_id_);
+  resource_provider_->UnlockForWrite(resource_);
 }
 
 SkSurface* ResourceProvider::ScopedWriteLockGr::GetSkSurface(
     bool use_distance_field_text) {
-  Resource* resource = resource_provider_->GetResource(resource_id_);
-  DCHECK(resource->locked_for_write);
+  DCHECK(resource_->locked_for_write);
 
   // If the surface doesn't exist, or doesn't have the correct dff setting,
   // recreate the surface within the resource.
-  if (!resource->sk_surface ||
+  if (!resource_->sk_surface ||
       use_distance_field_text !=
-          resource->sk_surface->props().isUseDistanceFieldFonts()) {
+          resource_->sk_surface->props().isUseDistanceFieldFonts()) {
     class GrContext* gr_context = resource_provider_->GrContext();
     // TODO(alokp): Implement TestContextProvider::GrContext().
     if (!gr_context)
       return nullptr;
 
-    resource_provider_->LazyAllocate(resource);
+    resource_provider_->LazyAllocate(resource_);
 
     GrBackendTextureDesc desc;
     desc.fFlags = kRenderTarget_GrBackendTextureFlag;
-    desc.fWidth = resource->size.width();
-    desc.fHeight = resource->size.height();
-    desc.fConfig = ToGrPixelConfig(resource->format);
+    desc.fWidth = resource_->size.width();
+    desc.fHeight = resource_->size.height();
+    desc.fConfig = ToGrPixelConfig(resource_->format);
     desc.fOrigin = kTopLeft_GrSurfaceOrigin;
-    desc.fTextureHandle = resource->gl_id;
+    desc.fTextureHandle = resource_->gl_id;
     skia::RefPtr<GrTexture> gr_texture =
         skia::AdoptRef(gr_context->wrapBackendTexture(desc));
     SkSurface::TextRenderMode text_render_mode =
         use_distance_field_text ? SkSurface::kDistanceField_TextRenderMode
                                 : SkSurface::kStandard_TextRenderMode;
-    resource->sk_surface = skia::AdoptRef(SkSurface::NewRenderTargetDirect(
+    resource_->sk_surface = skia::AdoptRef(SkSurface::NewRenderTargetDirect(
         gr_texture->asRenderTarget(), text_render_mode));
   }
-  return resource->sk_surface.get();
+  return resource_->sk_surface.get();
 }
 
 ResourceProvider::ResourceProvider(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
-    GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
@@ -1907,7 +1877,7 @@ bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   }
 
   resource->pending_set_pixels = false;
-  UnlockForWrite(id);
+  UnlockForWrite(resource);
 
   // Async set pixels commands are not necessarily processed in-sequence with
   // drawing commands. Read lock fences are required to ensure that async