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>
@@ skipping 302 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(Fence);
   };
 
   // Returns a RasterBuffer for gpu rasterization.
   // Call Release before the resource can be read or used for compositing.
   // It is used for direct gpu rasterization.
   RasterBuffer* AcquireGpuRasterBuffer(ResourceId id);
   void ReleaseGpuRasterBuffer(ResourceId id);
 
-  // Returns a RasterBuffer backed by an image buffer. ReleaseImageRasterBuffer
-  // returns true if RasterBuffer was written to while acquired.
+  // Returns a RasterBuffer backed by an image buffer.
   // Rasterizing to the RasterBuffer writes the content into the image buffer,
   // which is internally bound to the underlying resource when read.
   // Call Release before the resource can be read or used for compositing.
   // It is used by ImageRasterWorkerPool.
   RasterBuffer* AcquireImageRasterBuffer(ResourceId id);
-  bool ReleaseImageRasterBuffer(ResourceId id);
+  void ReleaseImageRasterBuffer(ResourceId id);
 
-  // Returns a RasterBuffer backed by pixel buffer. UnmapPixelRasterBuffer
-  // returns true if RasterBuffer was written to while acquired.
+  // Returns a RasterBuffer backed by pixel buffer.
   // 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);
+  RasterBuffer* AcquirePixelRasterBuffer(ResourceId id);
   void ReleasePixelRasterBuffer(ResourceId id);
-  RasterBuffer* 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 95 matching lines @@
   };
   typedef base::hash_map<ResourceId, Resource> ResourceMap;
 
   class GpuRasterBuffer : public RasterBuffer {
    public:
     GpuRasterBuffer(const Resource* resource,
                     ResourceProvider* resource_provider,
                     bool use_distance_field_text);
     virtual ~GpuRasterBuffer();
 
-    void LockForWrite();
-    // Returns true if canvas was written to while locked.
-    bool UnlockForWrite();
-
    protected:
-    const Resource* resource() const { return resource_; }
-    ResourceProvider* resource_provider() const { return resource_provider_; }
-
     skia::RefPtr<SkSurface> CreateSurface();
 
-    virtual SkCanvas* AcquireSkCanvas() OVERRIDE;
-    virtual void ReleaseSkCanvas() OVERRIDE;
+    virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
+    virtual bool ReleaseSkCanvas(SkCanvas* canvas) OVERRIDE;
 
    private:
     const Resource* resource_;
     ResourceProvider* resource_provider_;
-    SkCanvas* locked_canvas_;
-    int canvas_save_count_;
     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();
-
-    void LockForWrite();
-    // Returns true if canvas was written to while locked.
-    bool UnlockForWrite();
-
-   protected:
-    BitmapRasterBuffer(const Resource* resource,
-                       ResourceProvider* resource_provider);
-
-    const Resource* resource() const { return resource_; }
-    ResourceProvider* resource_provider() const { return resource_provider_; }
-
-    virtual SkCanvas* AcquireSkCanvas() OVERRIDE;
-    virtual void ReleaseSkCanvas() OVERRIDE;
-
-    virtual uint8_t* MapBuffer(int* stride) = 0;
-    virtual void UnmapBuffer() = 0;
-
-   private:
-    const Resource* resource_;
-    ResourceProvider* resource_provider_;
-    int canvas_save_count_;
-    uint8_t* mapped_buffer_;
-    SkBitmap raster_bitmap_;
-    uint32_t raster_bitmap_generation_id_;
-    bool raster_bitmap_changed_;
-    int stride_;
-    skia::RefPtr<SkCanvas> raster_canvas_;
-  };
-
-  class ImageRasterBuffer : public BitmapRasterBuffer {
+  class ImageRasterBuffer : public RasterBuffer {
    public:
     ImageRasterBuffer(const Resource* resource,
                       ResourceProvider* resource_provider);
     virtual ~ImageRasterBuffer();
 
+    void LockForWrite();
+    void UnlockForWrite();

[reveman, 2014/08/13 19:19:50]

Map/Unmap? I think that would better explain what these functions do.

[auygun, 2014/08/14 10:35:42]

Done.

+
    protected:
-    virtual uint8_t* MapBuffer(int* stride) OVERRIDE;
-    virtual void UnmapBuffer() OVERRIDE;
+    virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
+    virtual bool ReleaseSkCanvas(SkCanvas* canvas) OVERRIDE;
 
    private:
+    const Resource* resource_;
+    ResourceProvider* resource_provider_;
+    uint8_t* mapped_buffer_;
+    SkBitmap raster_bitmap_;
+    uint32_t raster_bitmap_generation_id_;
+    int stride_;
+
     DISALLOW_COPY_AND_ASSIGN(ImageRasterBuffer);
   };
 
-  class PixelRasterBuffer : public BitmapRasterBuffer {
+  class PixelRasterBuffer : public RasterBuffer {
    public:
     PixelRasterBuffer(const Resource* resource,
                       ResourceProvider* resource_provider);
     virtual ~PixelRasterBuffer();
 
+    void LockForWrite();
+    void UnlockForWrite();

[reveman, 2014/08/13 19:19:50]

Map/Unmap?

[auygun, 2014/08/14 10:35:42]

Done.

+
    protected:
-    virtual uint8_t* MapBuffer(int* stride) OVERRIDE;
-    virtual void UnmapBuffer() OVERRIDE;
+    virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
+    virtual bool ReleaseSkCanvas(SkCanvas* canvas) OVERRIDE;
 
    private:
+    const Resource* resource_;
+    ResourceProvider* resource_provider_;
+    uint8_t* mapped_buffer_;
+    SkBitmap raster_bitmap_;
+    uint32_t raster_bitmap_generation_id_;
+    int stride_;
+
     DISALLOW_COPY_AND_ASSIGN(PixelRasterBuffer);
   };
 
   static bool CompareResourceMapIteratorsByChildId(
       const std::pair<ReturnedResource, ResourceMap::iterator>& a,
       const std::pair<ReturnedResource, ResourceMap::iterator>& b);
 
   struct Child {
     Child();
     ~Child();
@@ skipping 149 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_