cc: Move RasterBuffer implementations from ResourceProvider to RasterWorkerPool implementations.

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"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/texture_uploader.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.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/utils/SkNullCanvas.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
@@ skipping 66 matching lines @@
       return kBGRA_8888_GrPixelConfig;
     case RGBA_4444:
       return kRGBA_4444_GrPixelConfig;
     default:
       break;
   }
   DCHECK(false) << "Unsupported resource format.";
   return kSkia8888_GrPixelConfig;
 }
 
-void MakeBitmap(SkBitmap* bitmap,
-                uint8_t* buffer,
-                ResourceFormat format,
-                const gfx::Size& size,
-                int stride) {
-  switch (format) {
-    case RGBA_4444:
-      // Use the default stride if we will eventually convert this
-      // bitmap to 4444.
-      bitmap->allocN32Pixels(size.width(), size.height());
-      break;
-    case RGBA_8888:
-    case BGRA_8888: {
-      SkImageInfo info =
-          SkImageInfo::MakeN32Premul(size.width(), size.height());
-      if (0 == stride)
-        stride = info.minRowBytes();
-      bitmap->installPixels(info, buffer, stride);
-      break;
-    }
-    case ALPHA_8:
-    case LUMINANCE_8:
-    case RGB_565:
-    case ETC1:
-      NOTREACHED();
-      break;
-  }
-}
-
-void CopyBitmap(const SkBitmap& src, uint8_t* dst, SkColorType dst_color_type) {
-  SkImageInfo dst_info = src.info();
-  dst_info.fColorType = dst_color_type;
-  // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
-  // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
-  // is fixed.
-  const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
-  CHECK_EQ(0u, dst_row_bytes % 4);
-  bool success = src.readPixels(dst_info, dst, dst_row_bytes, 0, 0);
-  CHECK_EQ(true, success);
-}
-
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
     DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
 
     if (unit_ != GL_TEXTURE0)
       GLC(gl_, gl_->ActiveTexture(unit_));
   }
 
@@ skipping 246 matching lines @@
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
       shared_bitmap(NULL) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
-ResourceProvider::GpuRasterBuffer::GpuRasterBuffer(
-    const Resource* resource,
-    ResourceProvider* resource_provider,
-    bool use_distance_field_text)
-    : resource_(resource), resource_provider_(resource_provider) {
-  DCHECK_EQ(GLTexture, resource_->type);
-  DCHECK(resource_->gl_id);
-
-  class GrContext* gr_context = resource_provider_->GrContext();
-  // TODO(alokp): Implement TestContextProvider::GrContext().
-  if (gr_context) {
-    GrBackendTextureDesc desc;
-    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
-    desc.fWidth = resource_->size.width();
-    desc.fHeight = resource_->size.height();
-    desc.fConfig = ToGrPixelConfig(resource_->format);
-    desc.fOrigin = kTopLeft_GrSurfaceOrigin;
-    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;
-    surface_ = skia::AdoptRef(SkSurface::NewRenderTargetDirect(
-        gr_texture->asRenderTarget(), text_render_mode));
-  }
-}
-
-ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
-}
-
-skia::RefPtr<SkCanvas> ResourceProvider::GpuRasterBuffer::AcquireSkCanvas() {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::GpuRasterBuffer::AcquireSkCanvas");
-
-  skia::RefPtr<SkCanvas> canvas = surface_
-                                      ? skia::SharePtr(surface_->getCanvas())
-                                      : skia::AdoptRef(SkCreateNullCanvas());
-  canvas->save();
-  return canvas;
-}
-
-void ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas(
-    const skia::RefPtr<SkCanvas>& canvas) {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas");
-
-  canvas->restore();
-}
-
-ResourceProvider::ImageRasterBuffer::ImageRasterBuffer(
-    const Resource* resource,
-    ResourceProvider* resource_provider)
-    : resource_(resource),
-      resource_provider_(resource_provider),
-      mapped_buffer_(NULL),
-      raster_bitmap_changed_(false),
-      stride_(0) {
-}
-
-ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() {
-}
-
-void ResourceProvider::ImageRasterBuffer::MapBuffer() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ImageRasterBuffer::MapBuffer");
-
-  DCHECK(!mapped_buffer_);
-
-  stride_ = 0;
-  mapped_buffer_ = resource_provider_->MapImage(resource_, &stride_);
-  raster_bitmap_changed_ = false;
-}
-
-bool ResourceProvider::ImageRasterBuffer::UnmapBuffer() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ImageRasterBuffer::UnmapBuffer");
-
-  if (mapped_buffer_) {
-    resource_provider_->UnmapImage(resource_);
-    mapped_buffer_ = NULL;
-  }
-  return raster_bitmap_changed_;
-}
-
-skia::RefPtr<SkCanvas> ResourceProvider::ImageRasterBuffer::AcquireSkCanvas() {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ImageRasterBuffer::AcquireSkCanvas");
-
-  if (!mapped_buffer_)
-    return skia::AdoptRef(SkCreateNullCanvas());
-
-  MakeBitmap(&raster_bitmap_,
-             mapped_buffer_,
-             resource_->format,
-             resource_->size,
-             stride_);
-  raster_bitmap_changed_ = true;
-  return skia::AdoptRef(new SkCanvas(raster_bitmap_));
-}
-
-void ResourceProvider::ImageRasterBuffer::ReleaseSkCanvas(
-    const skia::RefPtr<SkCanvas>& canvas) {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ImageRasterBuffer::ReleaseSkCanvas");
-
-  SkColorType buffer_colorType = ResourceFormatToSkColorType(resource_->format);
-  if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType()))
-    CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType);
-  raster_bitmap_.reset();
-}
-
-ResourceProvider::PixelRasterBuffer::PixelRasterBuffer(
-    const Resource* resource,
-    ResourceProvider* resource_provider)
-    : resource_(resource),
-      resource_provider_(resource_provider),
-      mapped_buffer_(NULL),
-      raster_bitmap_changed_(false),
-      stride_(0) {
-}
-
-ResourceProvider::PixelRasterBuffer::~PixelRasterBuffer() {
-}
-
-void ResourceProvider::PixelRasterBuffer::MapBuffer() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::PixelRasterBuffer::MapBuffer");
-
-  DCHECK(!mapped_buffer_);
-
-  stride_ = 0;
-  mapped_buffer_ = resource_provider_->MapPixelBuffer(resource_, &stride_);
-  raster_bitmap_changed_ = false;
-}
-
-bool ResourceProvider::PixelRasterBuffer::UnmapBuffer() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::PixelRasterBuffer::UnmapBuffer");
-
-  if (mapped_buffer_) {
-    resource_provider_->UnmapPixelBuffer(resource_);
-    mapped_buffer_ = NULL;
-  }
-  return raster_bitmap_changed_;
-}
-
-skia::RefPtr<SkCanvas> ResourceProvider::PixelRasterBuffer::AcquireSkCanvas() {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::PixelRasterBuffer::AcquireSkCanvas");
-
-  if (!mapped_buffer_)
-    return skia::AdoptRef(SkCreateNullCanvas());
-
-  MakeBitmap(&raster_bitmap_,
-             mapped_buffer_,
-             resource_->format,
-             resource_->size,
-             stride_);
-  raster_bitmap_changed_ = true;
-  return skia::AdoptRef(new SkCanvas(raster_bitmap_));
-}
-
-void ResourceProvider::PixelRasterBuffer::ReleaseSkCanvas(
-    const skia::RefPtr<SkCanvas>& canvas) {
-  // Note that this function is called from a worker thread.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::PixelRasterBuffer::ReleaseSkCanvas");
-
-  SkColorType buffer_colorType = ResourceFormatToSkColorType(resource_->format);
-  if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType()))
-    CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType);
-  raster_bitmap_.reset();
-}
-
 ResourceProvider::Child::Child() : marked_for_deletion(false) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
@@ skipping 235 matching lines @@
 void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
                                               DeleteStyle style) {
   TRACE_EVENT0("cc", "ResourceProvider::DeleteResourceInternal");
   Resource* resource = &it->second;
   bool lost_resource = resource->lost;
 
   DCHECK(resource->exported_count == 0 || style != Normal);
   if (style == ForShutdown && resource->exported_count > 0)
     lost_resource = true;
 
-  resource->gpu_raster_buffer.reset();
-  resource->image_raster_buffer.reset();
-  resource->pixel_raster_buffer.reset();
-
   if (resource->image_id) {
     DCHECK(resource->origin == Resource::Internal);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DestroyImageCHROMIUM(resource->image_id));
   }
   if (resource->gl_upload_query_id) {
     DCHECK(resource->origin == Resource::Internal);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
@@ skipping 880 matching lines @@
     child_info->return_callback.Run(to_return,
                                     blocking_main_thread_task_runner_);
 
   if (child_info->marked_for_deletion &&
       child_info->parent_to_child_map.empty()) {
     DCHECK(child_info->child_to_parent_map.empty());
     children_.erase(child_it);
   }
 }
 
-RasterBuffer* ResourceProvider::AcquireGpuRasterBuffer(ResourceId id) {
-  // Resource needs to be locked for write since GpuRasterBuffer writes
-  // directly to it.
-  LockForWrite(id);
-  Resource* resource = GetResource(id);
-  if (!resource->gpu_raster_buffer.get()) {
-    resource->gpu_raster_buffer.reset(
-        new GpuRasterBuffer(resource, this, use_distance_field_text_));
-  }
-  return resource->gpu_raster_buffer.get();
-}
-
-void ResourceProvider::ReleaseGpuRasterBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK(resource->gpu_raster_buffer.get());
-  UnlockForWrite(id);
-}
-
-RasterBuffer* ResourceProvider::AcquireImageRasterBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  AcquireImage(resource);
-  if (!resource->image_raster_buffer.get())
-    resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this));
-  resource->image_raster_buffer->MapBuffer();
-  return resource->image_raster_buffer.get();
-}
-
-bool ResourceProvider::ReleaseImageRasterBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  resource->dirty_image = true;
-  return resource->image_raster_buffer->UnmapBuffer();
-}
-
-RasterBuffer* ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  AcquirePixelBuffer(resource);
-  resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this));
-  resource->pixel_raster_buffer->MapBuffer();
-  return resource->pixel_raster_buffer.get();
-}
-
-bool ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) {
-  Resource* resource = GetResource(id);
-  DCHECK(resource->pixel_raster_buffer.get());
-  bool raster_bitmap_changed = resource->pixel_raster_buffer->UnmapBuffer();
-  resource->pixel_raster_buffer.reset();
-  ReleasePixelBuffer(resource);
-  return raster_bitmap_changed;
-}
-
-void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
+void ResourceProvider::AcquirePixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::AcquirePixelBuffer");
 
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
   DCHECK_NE(ETC1, resource->format);
 
   DCHECK_EQ(GLTexture, resource->type);
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   if (!resource->gl_pixel_buffer_id)
     resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
   gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->size.height() *
                      RoundUp(bytes_per_pixel * resource->size.width(), 4u),
                  NULL,
                  GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
-void ResourceProvider::ReleasePixelBuffer(Resource* resource) {
+void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::ReleasePixelBuffer");
 
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   // The pixel buffer can be released while there is a pending "set pixels"
   // if completion has been forced. Any shared memory associated with this
   // pixel buffer will not be freed until the waitAsyncTexImage2DCHROMIUM
   // command has been processed on the service side. It is also safe to
   // reuse any query id associated with this resource before they complete
   // as each new query has a unique submit count.
   if (resource->pending_set_pixels) {
     DCHECK(resource->set_pixels_completion_forced);
     resource->pending_set_pixels = false;
     resource->locked_for_write = false;
   }
 
   DCHECK_EQ(GLTexture, resource->type);
   if (!resource->gl_pixel_buffer_id)
     return;
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   gl->BufferData(
       GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0, NULL, GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
-uint8_t* ResourceProvider::MapPixelBuffer(const Resource* resource,
-                                          int* stride) {
+uint8_t* ResourceProvider::MapPixelBuffer(ResourceId id, int* stride) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::MapPixelBuffer");
 
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   *stride = 0;
   DCHECK_EQ(GLTexture, resource->type);
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   uint8_t* image = static_cast<uint8_t*>(gl->MapBufferCHROMIUM(
       GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   // Buffer is required to be 4-byte aligned.
   CHECK(!(reinterpret_cast<intptr_t>(image) & 3));
   return image;
 }
 
-void ResourceProvider::UnmapPixelBuffer(const Resource* resource) {
+void ResourceProvider::UnmapPixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::UnmapPixelBuffer");
 
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   DCHECK_EQ(GLTexture, resource->type);
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   gl->UnmapBufferCHROMIUM(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
-GLenum ResourceProvider::BindForSampling(
-    ResourceProvider::ResourceId resource_id,
-    GLenum unit,
-    GLenum filter) {
+GLenum ResourceProvider::BindForSampling(ResourceId resource_id,
+                                         GLenum unit,
+                                         GLenum filter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
   ResourceMap::iterator it = resources_.find(resource_id);
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
   DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
 
   ScopedSetActiveTexture scoped_active_tex(gl, unit);
   GLenum target = resource->target;
@@ skipping 10 matching lines @@
   return target;
 }
 
 void ResourceProvider::BeginSetPixels(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::BeginSetPixels");
 
   Resource* resource = GetResource(id);
   DCHECK(!resource->pending_set_pixels);
 
-  DCHECK(resource->pixel_raster_buffer.get());
-  bool raster_bitmap_changed = resource->pixel_raster_buffer->UnmapBuffer();
-  if (!raster_bitmap_changed)
-    return;
-
   LazyCreate(resource);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK(resource->gl_id || resource->allocated);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(!resource->image_id);
 
   bool allocate = !resource->allocated;
   resource->allocated = true;
   LockForWrite(id);
 
@@ skipping 37 matching lines @@
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::ForceSetPixelsToComplete");
 
   Resource* resource = GetResource(id);
 
-  if (!resource->pending_set_pixels)
-    return;
-
   DCHECK(resource->locked_for_write);
+  DCHECK(resource->pending_set_pixels);
   DCHECK(!resource->set_pixels_completion_forced);
 
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
     GLC(gl, gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
     GLC(gl, gl->BindTexture(GL_TEXTURE_2D, 0));
   }
 
   resource->set_pixels_completion_forced = true;
 }
 
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::DidSetPixelsComplete");
 
   Resource* resource = GetResource(id);
 
-  // Upload can be avoided as a result of raster bitmap not being modified.
-  // Assume the upload was completed in that case.
-  if (!resource->pending_set_pixels)
-    return true;
-
   DCHECK(resource->locked_for_write);
+  DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     DCHECK(resource->gl_upload_query_id);
     GLuint complete = 1;
     gl->GetQueryObjectuivEXT(
         resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete);
     if (!complete)
       return false;
@@ skipping 53 matching lines @@
                           GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
   }
 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
   LazyAllocate(GetResource(id));
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
+  if (resource->allocated)
+    return;
   LazyCreate(resource);
-
-  DCHECK(resource->gl_id || resource->allocated);
-  if (resource->allocated || !resource->gl_id)
+  if (!resource->gl_id)
     return;
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   ResourceFormat format = resource->format;
   GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
   if (use_texture_storage_ext_ &&
       IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
       (resource->hint & TextureHintImmutable)) {
@@ skipping 24 matching lines @@
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
   if (resource->bound_image_id)
     gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->bound_image_id);
   gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
   resource->bound_image_id = resource->image_id;
   resource->dirty_image = false;
 }
 
-void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id) {
+void ResourceProvider::EnableReadLockFences(ResourceId id) {
   Resource* resource = GetResource(id);
   resource->read_lock_fences_enabled = true;
 }
 
-void ResourceProvider::AcquireImage(Resource* resource) {
+void ResourceProvider::AcquireImage(ResourceId id) {
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->type != GLTexture)
     return;
 
   if (resource->image_id)
     return;
 
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   resource->image_id =
       gl->CreateImageCHROMIUM(resource->size.width(),
                               resource->size.height(),
                               TextureToStorageFormat(resource->format),
                               GL_IMAGE_MAP_CHROMIUM);
   DCHECK(resource->image_id);
 }
 
-void ResourceProvider::ReleaseImage(Resource* resource) {
+void ResourceProvider::ReleaseImage(ResourceId id) {
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (!resource->image_id)
     return;
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   gl->DestroyImageCHROMIUM(resource->image_id);
   resource->image_id = 0;
   resource->bound_image_id = 0;
   resource->dirty_image = false;
   resource->allocated = false;
 }
 
-uint8_t* ResourceProvider::MapImage(const Resource* resource, int* stride) {
+uint8_t* ResourceProvider::MapImage(ResourceId id, int* stride) {
+  Resource* resource = GetResource(id);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
+  LockForWrite(id);
 
   if (resource->type == GLTexture) {
     DCHECK(resource->image_id);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     // MapImageCHROMIUM should be called prior to GetImageParameterivCHROMIUM.
     uint8_t* pixels =
         static_cast<uint8_t*>(gl->MapImageCHROMIUM(resource->image_id));
     gl->GetImageParameterivCHROMIUM(
         resource->image_id, GL_IMAGE_ROWBYTES_CHROMIUM, stride);
     return pixels;
   }
   DCHECK_EQ(Bitmap, resource->type);
   *stride = 0;
   return resource->pixels;
 }
 
-void ResourceProvider::UnmapImage(const Resource* resource) {
+void ResourceProvider::UnmapImage(ResourceId id) {
+  Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
+  DCHECK(resource->locked_for_write);
 
   if (resource->image_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     gl->UnmapImageCHROMIUM(resource->image_id);
+    resource->dirty_image = true;
   }
+
+  UnlockForWrite(id);
+}
+
+void ResourceProvider::AcquireSkSurface(ResourceId id) {
+  Resource* resource = GetResource(id);
+  DCHECK(resource->origin == Resource::Internal);
+  DCHECK_EQ(resource->exported_count, 0);
+
+  if (resource->type != GLTexture)
+    return;
+
+  if (resource->sk_surface)
+    return;
+
+  class GrContext* gr_context = GrContext();
+  // TODO(alokp): Implement TestContextProvider::GrContext().
+  if (!gr_context)
+    return;
+
+  LazyAllocate(resource);
+
+  GrBackendTextureDesc desc;
+  desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+  desc.fWidth = resource->size.width();
+  desc.fHeight = resource->size.height();
+  desc.fConfig = ToGrPixelConfig(resource->format);
+  desc.fOrigin = kTopLeft_GrSurfaceOrigin;
+  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(
+      gr_texture->asRenderTarget(), text_render_mode));
+}
+
+void ResourceProvider::ReleaseSkSurface(ResourceId id) {
+  Resource* resource = GetResource(id);
+  DCHECK(resource->origin == Resource::Internal);
+  DCHECK_EQ(resource->exported_count, 0);
+
+  resource->sk_surface.clear();
+}
+
+SkSurface* ResourceProvider::LockForWriteToSkSurface(ResourceId id) {
+  Resource* resource = GetResource(id);
+  DCHECK(resource->origin == Resource::Internal);
+  DCHECK_EQ(resource->exported_count, 0);
+
+  LockForWrite(id);
+  return resource->sk_surface.get();
+}
+
+void ResourceProvider::UnlockForWriteToSkSurface(ResourceId id) {
+  UnlockForWrite(id);
 }
 
 void ResourceProvider::CopyResource(ResourceId source_id, ResourceId dest_id) {
   TRACE_EVENT0("cc", "ResourceProvider::CopyResource");
 
   Resource* source_resource = GetResource(source_id);
   DCHECK(!source_resource->lock_for_read_count);
   DCHECK(source_resource->origin == Resource::Internal);
   DCHECK_EQ(source_resource->exported_count, 0);
   DCHECK(source_resource->allocated);
@@ skipping 70 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc