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

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"
@@ skipping 378 matching lines @@
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureUsageAny),
       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::RasterBuffer::RasterBuffer(
-    const Resource* resource,
-    ResourceProvider* resource_provider)
-    : resource_(resource),
-      resource_provider_(resource_provider),
-      locked_canvas_(NULL),
-      canvas_save_count_(0) {
-  DCHECK(resource_);
-  DCHECK(resource_provider_);
-}
-
-ResourceProvider::RasterBuffer::~RasterBuffer() {}
-
-SkCanvas* ResourceProvider::RasterBuffer::LockForWrite() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::RasterBuffer::LockForWrite");
-
-  DCHECK(!locked_canvas_);
-
-  locked_canvas_ = DoLockForWrite();
-  canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
-  return locked_canvas_;
-}
-
-bool ResourceProvider::RasterBuffer::UnlockForWrite() {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::RasterBuffer::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),
+    : resource_(resource),
+      resource_provider_(resource_provider),
+      locked_canvas_(NULL),
+      canvas_save_count_(0),
       surface_generation_id_(0u),
       use_distance_field_text_(use_distance_field_text) {
 }
 
 ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
 }
 
-SkCanvas* ResourceProvider::GpuRasterBuffer::DoLockForWrite() {
+void ResourceProvider::GpuRasterBuffer::LockForWrite() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::GpuRasterBuffer::LockForWrite");
+
+  DCHECK(!locked_canvas_);
+
   if (!surface_)
     surface_ = CreateSurface();
   surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
-  return surface_ ? surface_->getCanvas() : NULL;
 }
 
-bool ResourceProvider::GpuRasterBuffer::DoUnlockForWrite() {
+bool ResourceProvider::GpuRasterBuffer::UnlockForWrite() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::GpuRasterBuffer::UnlockForWrite");
+
+  DCHECK(!locked_canvas_);
+
   // 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.
+  // of surface. Hence, a change since LockForWrite was called means the surface
+  // has changed.
   return surface_ ? surface_generation_id_ != surface_->generationID() : false;
 }
 
+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");
+
+  DCHECK(!locked_canvas_);
+  locked_canvas_ = surface_ ? surface_->getCanvas() : NULL;
+  canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
+  return locked_canvas_;
+}
+
+void ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas() {
+  // Note that this function is called from a worker thread.
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas");
+
+  if (locked_canvas_) {
+    locked_canvas_->restoreToCount(canvas_save_count_);
+    locked_canvas_ = NULL;
+  }
+}
+
 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
   DCHECK_EQ(GLTexture, resource()->type);
   DCHECK(resource()->gl_id);
 
   class GrContext* gr_context = resource_provider()->GrContext();
   // TODO(alokp): Implement TestContextProvider::GrContext().
   if (!gr_context)
     return skia::RefPtr<SkSurface>();
 
   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;
   return skia::AdoptRef(SkSurface::NewRenderTargetDirect(
       gr_texture->asRenderTarget(), text_render_mode));
 }
 
 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),
+      raster_bitmap_changed_(false),
+      stride_(0) {
+}
 
 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);
+  stride_ = 0;
+  mapped_buffer_ = MapBuffer(&stride_);
+  raster_bitmap_changed_ = false;
+}
+
+bool ResourceProvider::BitmapRasterBuffer::UnlockForWrite() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::UnlockForWrite");
+
+  DCHECK(!raster_canvas_);
+
+  UnmapBuffer();
+  mapped_buffer_ = NULL;
+  return raster_bitmap_changed_;
+}
+
+SkCanvas* ResourceProvider::BitmapRasterBuffer::AcquireSkCanvas() {
+  // Note that this function is called from a worker thread.
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::AcquireSkCanvas");
+
   if (!mapped_buffer_)
     return NULL;
 
   switch (resource()->format) {
     case RGBA_4444:
       // Use the default stride if we will eventually convert this
       // bitmap to 4444.
       raster_bitmap_.allocN32Pixels(resource()->size.width(),
                                     resource()->size.height());
       break;
     case RGBA_8888:
     case BGRA_8888: {
       SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(),
                                                     resource()->size.height());
-      if (0 == stride)
-        stride = info.minRowBytes();
-      raster_bitmap_.installPixels(info, mapped_buffer_, stride);
+      if (0 == stride_)
+        stride_ = info.minRowBytes();
+      raster_bitmap_.installPixels(info, mapped_buffer_, stride_);
       break;
     }
     case LUMINANCE_8:
     case RGB_565:
     case ETC1:
       NOTREACHED();
       break;
   }
+
+  raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
+
+  DCHECK(!raster_canvas_);
   raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_));
-  raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
+  canvas_save_count_ = raster_canvas_->save();
   return raster_canvas_.get();
 }
 
-bool ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() {
-  raster_canvas_.clear();
+void ResourceProvider::BitmapRasterBuffer::ReleaseSkCanvas() {
+  // Note that this function is called from a worker thread.
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "ResourceProvider::BitmapRasterBuffer::ReleaseSkCanvas");
+
+  if (raster_canvas_) {
+    raster_canvas_->restoreToCount(canvas_save_count_);
+    raster_canvas_.clear();
+  }
 
   // getGenerationID returns a non-zero, unique value corresponding to the
-  // pixels in bitmap. Hence, a change since DoLockForWrite was called means the
+  // pixels in bitmap. Hence, a change since LockForWrite was called means the
   // bitmap has changed.
-  bool raster_bitmap_changed =
+  raster_bitmap_changed_ =
       raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();
-
-  if (raster_bitmap_changed) {
+  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(
     const Resource* resource,
     ResourceProvider* resource_provider)
     : BitmapRasterBuffer(resource, resource_provider) {}
 
 ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() {}
 
 uint8_t* ResourceProvider::ImageRasterBuffer::MapBuffer(int* stride) {
@@ skipping 1160 matching lines @@
   if (!to_return.empty())
     child_info->return_callback.Run(to_return);
 
   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);
   }
 }
 
-SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
+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->LockForWrite();
+  resource->gpu_raster_buffer->LockForWrite();
+  return resource->gpu_raster_buffer.get();
 }
 
-void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) {
+void ResourceProvider::ReleaseGpuRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource->gpu_raster_buffer.get());
   resource->gpu_raster_buffer->UnlockForWrite();
   UnlockForWrite(id);
 }
 
-SkCanvas* ResourceProvider::MapImageRasterBuffer(ResourceId 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));
-  return resource->image_raster_buffer->LockForWrite();
+  resource->image_raster_buffer->LockForWrite();
+  return resource->image_raster_buffer.get();
 }
 
-bool ResourceProvider::UnmapImageRasterBuffer(ResourceId id) {
+bool ResourceProvider::ReleaseImageRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   resource->dirty_image = true;
   return resource->image_raster_buffer->UnlockForWrite();
 }
 
 void ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   AcquirePixelBuffer(resource);
   resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this));
 }
 
 void ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   resource->pixel_raster_buffer.reset();
   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) {
   Resource* resource = GetResource(id);
   DCHECK(resource->pixel_raster_buffer.get());
   return resource->pixel_raster_buffer->UnlockForWrite();
 }
 
 void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 463 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