cc: Do bitmap conversion for RasterBuffer in the worker thread.

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 ff0652465d9047447fb376bd097988db9828acdb..27d3effe496f0b5c15de21737bcef0853027fcad 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -396,67 +396,53 @@ ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
-ResourceProvider::RasterBuffer::RasterBuffer(
+ResourceProvider::GpuRasterBuffer::GpuRasterBuffer(
     const Resource* resource,
-    ResourceProvider* resource_provider)
+    ResourceProvider* resource_provider,
+    bool use_distance_field_text)
     : resource_(resource),
       resource_provider_(resource_provider),
       locked_canvas_(NULL),
-      canvas_save_count_(0) {
-  DCHECK(resource_);
-  DCHECK(resource_provider_);
+      canvas_save_count_(0),
+      surface_generation_id_(0u),
+      use_distance_field_text_(use_distance_field_text) {
 }
 
-ResourceProvider::RasterBuffer::~RasterBuffer() {}
+ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
+}
 
-SkCanvas* ResourceProvider::RasterBuffer::LockForWrite() {
+void ResourceProvider::GpuRasterBuffer::LockForWrite() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::RasterBuffer::LockForWrite");
+               "ResourceProvider::GpuRasterBuffer::LockForWrite");
 
-  DCHECK(!locked_canvas_);
+  if (!surface_)
+    surface_ = CreateSurface();
+  surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
 
-  locked_canvas_ = DoLockForWrite();
+  DCHECK(!locked_canvas_);
+  locked_canvas_ = surface_ ? surface_->getCanvas() : NULL;
   canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
-  return locked_canvas_;
 }
 
-bool ResourceProvider::RasterBuffer::UnlockForWrite() {
+bool ResourceProvider::GpuRasterBuffer::UnlockForWrite() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::RasterBuffer::UnlockForWrite");
+               "ResourceProvider::GpuRasterBuffer::UnlockForWrite");
 
   if (locked_canvas_) {
     locked_canvas_->restoreToCount(canvas_save_count_);
     locked_canvas_ = NULL;
   }
-  return DoUnlockForWrite();
-}
-
-ResourceProvider::GpuRasterBuffer::GpuRasterBuffer(
-    const Resource* resource,
-    ResourceProvider* resource_provider,
-    bool use_distance_field_text)
-    : RasterBuffer(resource, resource_provider),
-      surface_generation_id_(0u),
-      use_distance_field_text_(use_distance_field_text) {
-}
-
-ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
-}
-
-SkCanvas* ResourceProvider::GpuRasterBuffer::DoLockForWrite() {
-  if (!surface_)
-    surface_ = CreateSurface();
-  surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
-  return surface_ ? surface_->getCanvas() : NULL;
-}
 
-bool ResourceProvider::GpuRasterBuffer::DoUnlockForWrite() {
   // generationID returns a non-zero, unique value corresponding to the content
   // of surface. Hence, a change since DoLockForWrite was called means the
   // surface has changed.
   return surface_ ? surface_generation_id_ != surface_->generationID() : false;
 }
 
+SkCanvas* ResourceProvider::GpuRasterBuffer::GetSkCanvas() {
+  return locked_canvas_;
+}
+
 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
   DCHECK_EQ(GLTexture, resource()->type);
   DCHECK(resource()->gl_id);
@@ -485,20 +471,26 @@ skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer(
     const Resource* resource,
     ResourceProvider* resource_provider)
-    : RasterBuffer(resource, resource_provider),
+    : resource_(resource),
+      resource_provider_(resource_provider),
+      canvas_save_count_(0),
       mapped_buffer_(NULL),
-      raster_bitmap_generation_id_(0u) {}
+      raster_bitmap_generation_id_(0u) {
+}
 
 ResourceProvider::BitmapRasterBuffer::~BitmapRasterBuffer() {}
 
-SkCanvas* ResourceProvider::BitmapRasterBuffer::DoLockForWrite() {
+void ResourceProvider::BitmapRasterBuffer::LockForWrite() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::LockForWrite");
+
   DCHECK(!mapped_buffer_);
   DCHECK(!raster_canvas_);
 
   int stride = 0;
   mapped_buffer_ = MapBuffer(&stride);
   if (!mapped_buffer_)
-    return NULL;
+    return;
 
   switch (resource()->format) {
     case RGBA_4444:
@@ -522,31 +514,50 @@ SkCanvas* ResourceProvider::BitmapRasterBuffer::DoLockForWrite() {
       NOTREACHED();
       break;
   }
+
   raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_));
   raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
+  canvas_save_count_ = raster_canvas_->save();
+}
+
+bool ResourceProvider::BitmapRasterBuffer::UnlockForWrite() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::UnlockForWrite");
+
+  if (raster_canvas_) {
+    raster_canvas_->restoreToCount(canvas_save_count_);
+    raster_canvas_.clear();
+  }
+
+  bool raster_bitmap_changed =
+      raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();
+  raster_bitmap_.reset();
+
+  UnmapBuffer();
+  mapped_buffer_ = NULL;
+  return raster_bitmap_changed;
+}
+
+SkCanvas* ResourceProvider::BitmapRasterBuffer::GetSkCanvas() {
   return raster_canvas_.get();
 }
 
-bool ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() {
-  raster_canvas_.clear();
+void ResourceProvider::BitmapRasterBuffer::Flush() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::Flush");
+  // Note that this function is called from a worker thread.
 
   // getGenerationID returns a non-zero, unique value corresponding to the
   // pixels in bitmap. Hence, a change since DoLockForWrite was called means the
   // bitmap has changed.
   bool raster_bitmap_changed =
       raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();
-
   if (raster_bitmap_changed) {
     SkColorType buffer_colorType =
         ResourceFormatToSkColorType(resource()->format);
     if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType()))
       CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType);
   }
-  raster_bitmap_.reset();
-
-  UnmapBuffer();
-  mapped_buffer_ = NULL;
-  return raster_bitmap_changed;
 }
 
 ResourceProvider::ImageRasterBuffer::ImageRasterBuffer(
@@ -1727,7 +1738,7 @@ void ResourceProvider::DeleteAndReturnUnusedResourcesToChild(
   }
 }
 
-SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
+RasterBuffer* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
   // Resource needs to be locked for write since GpuRasterBuffer writes
   // directly to it.
   LockForWrite(id);
@@ -1736,7 +1747,8 @@ SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
     resource->gpu_raster_buffer.reset(
         new GpuRasterBuffer(resource, this, use_distance_field_text_));
   }
-  return resource->gpu_raster_buffer->LockForWrite();
+  resource->gpu_raster_buffer->LockForWrite();
+  return resource->gpu_raster_buffer.get();
 }
 
 void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) {
@@ -1746,12 +1758,13 @@ void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) {
   UnlockForWrite(id);
 }
 
-SkCanvas* ResourceProvider::MapImageRasterBuffer(ResourceId id) {
+RasterBuffer* ResourceProvider::MapImageRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   AcquireImage(resource);
   if (!resource->image_raster_buffer.get())
     resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this));
-  return resource->image_raster_buffer->LockForWrite();
+  resource->image_raster_buffer->LockForWrite();
+  return resource->image_raster_buffer.get();
 }
 
 bool ResourceProvider::UnmapImageRasterBuffer(ResourceId id) {
@@ -1772,10 +1785,11 @@ void ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) {
   ReleasePixelBuffer(resource);
 }
 
-SkCanvas* ResourceProvider::MapPixelRasterBuffer(ResourceId id) {
+RasterBuffer* ResourceProvider::MapPixelRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource->pixel_raster_buffer.get());
-  return resource->pixel_raster_buffer->LockForWrite();
+  resource->pixel_raster_buffer->LockForWrite();
+  return resource->pixel_raster_buffer.get();
 }
 
 bool ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) {