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

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
+#include "cc/resources/rasterizer.h"
 #include "cc/resources/release_callback.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/return_callback.h"
 #include "cc/resources/shared_bitmap.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/resources/transferable_resource.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 276 matching lines @@
     friend class base::RefCounted<Fence>;
     virtual ~Fence() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Fence);
   };
 
   // Returns a canvas for gpu rasterization.
   // Call Unmap before the resource can be read or used for compositing.
   // It is used for direct gpu rasterization.
-  SkCanvas* MapGpuRasterBuffer(ResourceId id);
+  RasterCanvas* MapGpuRasterBuffer(ResourceId id);
   void UnmapGpuRasterBuffer(ResourceId id);
 
   // Returns a canvas backed by an image buffer. UnmapImageRasterBuffer
   // returns true if canvas was written to while mapped.
   // Rasterizing to the canvas writes the content into the image buffer,
   // which is internally bound to the underlying resource when read.
   // Call Unmap before the resource can be read or used for compositing.
   // It is used by ImageRasterWorkerPool.
-  SkCanvas* MapImageRasterBuffer(ResourceId id);
+  RasterCanvas* MapImageRasterBuffer(ResourceId id);
   bool UnmapImageRasterBuffer(ResourceId id);
 
   // Returns a canvas backed by pixel buffer. UnmapPixelRasterBuffer
   // returns true if canvas was written to while mapped.
   // The pixel buffer needs to be uploaded to the underlying resource
   // using BeginSetPixels before the resouce can be used for compositing.
   // It is used by PixelRasterWorkerPool.
   void AcquirePixelRasterBuffer(ResourceId id);
   void ReleasePixelRasterBuffer(ResourceId id);
-  SkCanvas* MapPixelRasterBuffer(ResourceId id);
+  RasterCanvas* MapPixelRasterBuffer(ResourceId id);
   bool UnmapPixelRasterBuffer(ResourceId id);
 
   // Asynchronously update pixels from acquired pixel buffer.
   void BeginSetPixels(ResourceId id);
   void ForceSetPixelsToComplete(ResourceId id);
   bool DidSetPixelsComplete(ResourceId id);
 
   // For tests only! This prevents detecting uninitialized reads.
   // Use SetPixels or LockForWrite to allocate implicitly.
   void AllocateForTesting(ResourceId id);
@@ skipping 89 matching lines @@
     ResourceType type;
     ResourceFormat format;
     SharedBitmapId shared_bitmap_id;
     SharedBitmap* shared_bitmap;
     linked_ptr<GpuRasterBuffer> gpu_raster_buffer;
     linked_ptr<ImageRasterBuffer> image_raster_buffer;
     linked_ptr<PixelRasterBuffer> pixel_raster_buffer;
   };
   typedef base::hash_map<ResourceId, Resource> ResourceMap;
 
-  class RasterBuffer {
+  class RasterBuffer : public RasterCanvas {

[reveman, 2014/08/11 11:46:21]

Do we need both a RasterBuffer and a RasterCanvas interface? I'm not a fan of
the existing use of inheritance for RasterBuffer code reuse. Maybe we can make
RasterBuffer the public interface used by raster tasks and use a more
appropriate mechanism for code reuse in RP.   

[auygun, 2014/08/11 14:03:00]

I'll try to do that. Looks like RasterBuffer can easily be removed. I don't
think lock/unlock functions need to be virtuals.

    public:
     virtual ~RasterBuffer();
 
-    SkCanvas* LockForWrite();
+    void LockForWrite();
     // Returns true if canvas was written to while locked.
     bool UnlockForWrite();
 
    protected:
     RasterBuffer(const Resource* resource, ResourceProvider* resource_provider);
     const Resource* resource() const { return resource_; }
     ResourceProvider* resource_provider() const { return resource_provider_; }
 
     virtual SkCanvas* DoLockForWrite() = 0;
     virtual bool DoUnlockForWrite() = 0;
 
    private:
     const Resource* resource_;
     ResourceProvider* resource_provider_;
-    SkCanvas* locked_canvas_;
     int canvas_save_count_;
   };
 
   class GpuRasterBuffer : public RasterBuffer {
    public:
     GpuRasterBuffer(const Resource* resource,
                     ResourceProvider* resource_provider,
                     bool use_distance_field_text);
     virtual ~GpuRasterBuffer();
 
    protected:
     virtual SkCanvas* DoLockForWrite() OVERRIDE;
     virtual bool DoUnlockForWrite() OVERRIDE;
+    virtual void Flush() OVERRIDE {}
     skia::RefPtr<SkSurface> CreateSurface();
 
    private:
     skia::RefPtr<SkSurface> surface_;
     uint32_t surface_generation_id_;
     const bool use_distance_field_text_;
 
     DISALLOW_COPY_AND_ASSIGN(GpuRasterBuffer);
   };
 
   class BitmapRasterBuffer : public RasterBuffer {
    public:
     virtual ~BitmapRasterBuffer();
 
    protected:
     BitmapRasterBuffer(const Resource* resource,
                        ResourceProvider* resource_provider);
 
     virtual SkCanvas* DoLockForWrite() OVERRIDE;
     virtual bool DoUnlockForWrite() OVERRIDE;
+    virtual void Flush() OVERRIDE;
 
     virtual uint8_t* MapBuffer(int* stride) = 0;
     virtual void UnmapBuffer() = 0;
 
    private:
     uint8_t* mapped_buffer_;
     SkBitmap raster_bitmap_;
     uint32_t raster_bitmap_generation_id_;
     skia::RefPtr<SkCanvas> raster_canvas_;
   };
@@ skipping 185 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_