Re-land: cc: Cleanup internal::WorkerPoolTaskClient interface.

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 371 matching lines @@
 ResourceProvider::RasterBuffer::~RasterBuffer() {}
 
 SkCanvas* ResourceProvider::RasterBuffer::LockForWrite() {
   DCHECK(!locked_canvas_);
 
   locked_canvas_ = DoLockForWrite();
   canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
   return locked_canvas_;
 }
 
-void ResourceProvider::RasterBuffer::UnlockForWrite() {
+bool ResourceProvider::RasterBuffer::UnlockForWrite() {
   if (locked_canvas_) {
     locked_canvas_->restoreToCount(canvas_save_count_);
     locked_canvas_ = NULL;
   }
-  DoUnlockForWrite();
+  return DoUnlockForWrite();
 }
 
 ResourceProvider::DirectRasterBuffer::DirectRasterBuffer(
     const Resource* resource,
     ResourceProvider* resource_provider)
-    : RasterBuffer(resource, resource_provider) {}
+    : RasterBuffer(resource, resource_provider), surface_generation_id_(0u) {}
 
 ResourceProvider::DirectRasterBuffer::~DirectRasterBuffer() {}
 
 SkCanvas* ResourceProvider::DirectRasterBuffer::DoLockForWrite() {
   if (!surface_)
     surface_ = CreateSurface();
+  surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
   return surface_ ? surface_->getCanvas() : NULL;
 }
 
-void ResourceProvider::DirectRasterBuffer::DoUnlockForWrite() {}
+bool ResourceProvider::DirectRasterBuffer::DoUnlockForWrite() {
+  return surface_ ? surface_generation_id_ != surface_->generationID() : false;
+}
 
 skia::RefPtr<SkSurface> ResourceProvider::DirectRasterBuffer::CreateSurface() {
   skia::RefPtr<SkSurface> surface;
   switch (resource()->type) {
     case GLTexture: {
       DCHECK(resource()->gl_id);
       class GrContext* gr_context = resource_provider()->GrContext();
       if (gr_context) {
         GrBackendTextureDesc desc;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
@@ skipping 22 matching lines @@
     }
     default:
       NOTREACHED();
   }
   return surface;
 }
 
 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer(
     const Resource* resource,
     ResourceProvider* resource_provider)
-    : RasterBuffer(resource, resource_provider), mapped_buffer_(NULL) {}
+    : RasterBuffer(resource, resource_provider),
+      mapped_buffer_(NULL),
+      raster_bitmap_generation_id_(0u) {}
 
 ResourceProvider::BitmapRasterBuffer::~BitmapRasterBuffer() {}
 
 SkCanvas* ResourceProvider::BitmapRasterBuffer::DoLockForWrite() {
   DCHECK(!mapped_buffer_);
   DCHECK(!raster_canvas_);
 
   int stride = 0;
   mapped_buffer_ = MapBuffer(&stride);
   if (!mapped_buffer_)
@@ skipping 18 matching lines @@
       break;
     case LUMINANCE_8:
     case RGB_565:
     case ETC1:
       NOTREACHED();
       break;
   }
   skia::RefPtr<SkBitmapDevice> device =
       skia::AdoptRef(new SkBitmapDevice(raster_bitmap_));
   raster_canvas_ = skia::AdoptRef(new SkCanvas(device.get()));
+  raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
   return raster_canvas_.get();
 }
 
-void ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() {
+bool ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() {
   raster_canvas_.clear();
 
-  SkBitmap::Config buffer_config = SkBitmapConfig(resource()->format);
-  if (mapped_buffer_ && (buffer_config != raster_bitmap_.config()))
-    CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_config);
+  bool raster_bitmap_changed =
+      raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();

[vmpstr, 2014/02/19 00:49:31]

Is this like a good check? According to skia header files, I can buy that this
works, but have you verified it in most cases?

Also, can you put a comment here explaining what's happening?

[reveman, 2014/02/19 01:41:13]

Done.

+
+  if (raster_bitmap_changed) {
+    SkBitmap::Config buffer_config = SkBitmapConfig(resource()->format);
+    if (mapped_buffer_ && (buffer_config != raster_bitmap_.config()))
+      CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_config);
+  }
   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 1212 matching lines @@
   resource->pixel_raster_buffer.reset();
   ReleasePixelBuffer(resource);
 }
 
 SkCanvas* ResourceProvider::MapPixelRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource->pixel_raster_buffer.get());
   return resource->pixel_raster_buffer->LockForWrite();
 }
 
-void ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) {
+bool ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource->pixel_raster_buffer.get());
-  resource->pixel_raster_buffer->UnlockForWrite();
+  return resource->pixel_raster_buffer->UnlockForWrite();
 }
 
 void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
   DCHECK_NE(ETC1, resource->format);
 
   if (resource->type == GLTexture) {
     GLES2Interface* gl = ContextGL();
@@ skipping 406 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