cc: Refactor WorkerPoolTaskClient::AcquireBufferForRaster

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/release_callback.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/return_callback.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"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/size.h"
 
+class GrContext;
+
 namespace gpu {
 namespace gles {
 class GLES2Interface;
 }
 }
 
 namespace gfx {
 class Rect;
 class Vector2d;
 }
@@ skipping 256 matching lines @@
     virtual bool HasPassed() = 0;
 
    protected:
     friend class base::RefCounted<Fence>;
     virtual ~Fence() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Fence);
   };
 
-  // Acquire pixel buffer for resource. The pixel buffer can be used to
-  // set resource pixels without performing unnecessary copying.
-  void AcquirePixelBuffer(ResourceId id);
-  void ReleasePixelBuffer(ResourceId id);
+  SkCanvas* MapDirectRasterBuffer(ResourceId id);
+  void UnmapDirectRasterBuffer(ResourceId id);
 
-  // Map/unmap the acquired pixel buffer.
-  uint8_t* MapPixelBuffer(ResourceId id);
-  void UnmapPixelBuffer(ResourceId id);
+  SkCanvas* MapImageRasterBuffer(ResourceId id);
+  void UnmapImageRasterBuffer(ResourceId id);
+
+  void AcquirePixelRasterBuffer(ResourceId id);
+  void ReleasePixelRasterBuffer(ResourceId id);
+  SkCanvas* MapPixelRasterBuffer(ResourceId id);
+  void UnmapPixelRasterBuffer(ResourceId id);
 
   // Asynchronously update pixels from acquired pixel buffer.
   void BeginSetPixels(ResourceId id);
   void ForceSetPixelsToComplete(ResourceId id);
   bool DidSetPixelsComplete(ResourceId id);
 
-  // Acquire and release an image. The image allows direct
-  // manipulation of texture memory.
-  void AcquireImage(ResourceId id);
-  void ReleaseImage(ResourceId id);
-
-  // Maps the acquired image so that its pixels could be modified.
-  // Unmap is called when all pixels are set.
-  uint8_t* MapImage(ResourceId id);
-  void UnmapImage(ResourceId id);
-
-  // Returns the stride for the image.
-  int GetImageStride(ResourceId id);
-
   // For tests only! This prevents detecting uninitialized reads.
   // Use SetPixels or LockForWrite to allocate implicitly.
   void AllocateForTesting(ResourceId id);
 
   // For tests only!
   void CreateForTesting(ResourceId id);
 
   GLenum TargetForTesting(ResourceId id);
 
   // Sets the current read fence. If a resource is locked for read
   // and has read fences enabled, the resource will not allow writes
   // until this fence has passed.
   void SetReadLockFence(scoped_refptr<Fence> fence) {
     current_read_lock_fence_ = fence;
   }
   Fence* GetReadLockFence() { return current_read_lock_fence_.get(); }
 
   // Enable read lock fences for a specific resource.
   void EnableReadLockFences(ResourceProvider::ResourceId id, bool enable);
 
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
   static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
 
  private:
+  class DirectRasterBuffer;
+  class ImageRasterBuffer;
+  class PixelRasterBuffer;
+
   struct Resource {
     enum Origin { Internal, External, Delegated };
 
     Resource();
     ~Resource();
     Resource(unsigned texture_id,
              const gfx::Size& size,
              Origin origin,
              GLenum target,
              GLenum filter,
@@ skipping 37 matching lines @@
     unsigned image_id;
     unsigned bound_image_id;
     bool dirty_image;
     GLenum texture_pool;
     GLint wrap_mode;
     bool lost;
     TextureUsageHint hint;
     ResourceType type;
     ResourceFormat format;
     SharedBitmap* shared_bitmap;
+    linked_ptr<DirectRasterBuffer> direct_raster_buffer;
+    linked_ptr<ImageRasterBuffer> image_raster_buffer;
+    linked_ptr<PixelRasterBuffer> pixel_raster_buffer;

[reveman, 2014/02/11 02:00:44]

scoped_ptr would be preferred but I assume this needs to be copyable, right?

How about making all these linked_ptr<RasterBuffer> and move the declaration of
all the different implementations into the .cc file? That would clean up the .h
quite a bit.

[alokp, 2014/02/11 07:05:21]

Yes. It needs to be copyable.
Once this is landed, I plan to move the implementation of
Acquire/Release/Map/Unmap Image/Pixel into these classes. I also plan to  move a
few member variables of Resource into these classes, in which case just using
the RasterBuffer API may not be sufficient. I do not want to static_cast to use
a particular Image/PixelRasterBuffer member function.

Having said that I may be able to move the RasterBuffer outside ResourceProvider
if RasterBuffer can simply use cc::Resource. I would like to concentrate on
cleaning up the RWP in this patch. I will clean up the internal API in later
patches.

   };
   typedef base::hash_map<ResourceId, Resource> ResourceMap;
 
+  class RasterBuffer {
+   public:
+    virtual ~RasterBuffer();
+
+    SkCanvas* LockForWrite();
+    void 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 void DoUnlockForWrite() = 0;
+
+   private:
+    const Resource* resource_;
+    ResourceProvider* resource_provider_;
+    SkCanvas* locked_canvas_;
+    int canvas_save_count_;
+  };
+
+  class DirectRasterBuffer : public RasterBuffer {
+   public:
+    DirectRasterBuffer(const Resource* resource,
+                       ResourceProvider* resource_provider);
+    virtual ~DirectRasterBuffer();
+
+   protected:
+    virtual SkCanvas* DoLockForWrite() OVERRIDE;
+    virtual void DoUnlockForWrite() OVERRIDE;
+    skia::RefPtr<SkSurface> CreateSurface();
+
+   private:
+    skia::RefPtr<SkSurface> surface_;
+    DISALLOW_COPY_AND_ASSIGN(DirectRasterBuffer);
+  };
+
+  class BitmapRasterBuffer : public RasterBuffer {
+   public:
+    virtual ~BitmapRasterBuffer();
+
+   protected:
+    BitmapRasterBuffer(const Resource* resource,
+                       ResourceProvider* resource_provider);
+
+    virtual SkCanvas* DoLockForWrite() OVERRIDE;
+    virtual void DoUnlockForWrite() OVERRIDE;
+
+    virtual uint8_t* MapBuffer(int* stride) = 0;
+    virtual void UnmapBuffer() = 0;
+
+   private:
+    uint8_t* buffer_;
+    skia::RefPtr<SkCanvas> canvas_;
+  };
+
+  class ImageRasterBuffer : public BitmapRasterBuffer {
+   public:
+    ImageRasterBuffer(const Resource* resource,
+                      ResourceProvider* resource_provider);
+    virtual ~ImageRasterBuffer();
+
+   protected:
+    virtual uint8_t* MapBuffer(int* stride) OVERRIDE;
+    virtual void UnmapBuffer() OVERRIDE;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ImageRasterBuffer);
+  };
+
+  class PixelRasterBuffer : public BitmapRasterBuffer {
+   public:
+    PixelRasterBuffer(const Resource* resource,
+                      ResourceProvider* resource_provider);
+    virtual ~PixelRasterBuffer();
+
+   protected:
+    virtual uint8_t* MapBuffer(int* stride) OVERRIDE;
+    virtual void UnmapBuffer() OVERRIDE;
+
+   private:
+    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();
 
     ResourceIdMap child_to_parent_map;
     ResourceIdMap parent_to_child_map;
     ReturnCallback return_callback;
     ResourceIdSet in_use_resources;
     bool marked_for_deletion;
   };
   typedef base::hash_map<int, Child> ChildMap;
 
-  bool ReadLockFenceHasPassed(Resource* resource) {
+  bool ReadLockFenceHasPassed(const Resource* resource) {
     return !resource->read_lock_fence.get() ||
            resource->read_lock_fence->HasPassed();
   }
 
   ResourceProvider(OutputSurface* output_surface,
                    SharedBitmapManager* shared_bitmap_manager,
                    int highp_threshold_min,
                    bool use_rgba_4444_texture_format,
                    size_t id_allocation_chunk_size);
 
@@ skipping 14 matching lines @@
     Normal,
     ForShutdown,
   };
   void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
   void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
                                              DeleteStyle style,
                                              const ResourceIdArray& unused);
   void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
   void LazyCreate(Resource* resource);
   void LazyAllocate(Resource* resource);
+
+  // TODO(alokp): Move the implementation to PixelRasterBuffer.
+  // Acquire pixel buffer for resource. The pixel buffer can be used to
+  // set resource pixels without performing unnecessary copying.
+  void AcquirePixelBuffer(Resource* resource);
+  void ReleasePixelBuffer(Resource* resource);
+  // Map/unmap the acquired pixel buffer.
+  uint8_t* MapPixelBuffer(const Resource* resource, int* stride);
+  void UnmapPixelBuffer(const Resource* resource);
+
+  // TODO(alokp): Move the implementation to ImageRasterBuffer.
+  // Acquire and release an image. The image allows direct
+  // manipulation of texture memory.
+  void AcquireImage(Resource* resource);
+  void ReleaseImage(Resource* resource);
+  // Maps the acquired image so that its pixels could be modified.
+  // Unmap is called when all pixels are set.
+  uint8_t* MapImage(const Resource* resource, int* stride);
+  void UnmapImage(const Resource* resource);
+
   void BindImageForSampling(Resource* resource);
-
   // Binds the given GL resource to a texture target for sampling using the
   // specified filter for both minification and magnification. Returns the
   // texture target used. The resource must be locked for reading.
   GLenum BindForSampling(ResourceProvider::ResourceId resource_id,
                          GLenum unit,
                          GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
   gpu::gles2::GLES2Interface* ContextGL() const;
+  class GrContext* GrContext() const;
 
   OutputSurface* output_surface_;
   SharedBitmapManager* shared_bitmap_manager_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
   int next_child_;
   ChildMap children_;
 
@@ skipping 59 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_