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);

[reveman, 2014/02/12 01:45:12]

Not clear to me what the "Direct" means here. Writes direct to the resource? So
does ImageRasterBuffer. Seems like this provides duplicate functionality in case
of sw resources...

What difference can I expect from this compared ImageRasterBuffer version? For
image version the raster cost is payed during draw. Is that the important
difference? In that case, DirectRasterBuffer with sw resources is not really
doing the right thing..

PixelBuffer version and Direct version in some ways have more in common. They
both have async behavior that require something like "DidSetPixelsComplete" to
determine when done..

Would be nice to establish the difference between these functions and document
it here.

[alokp, 2014/02/12 07:17:42]

I consider image and pixel raster buffers indirect because you first write to an
intermediate buffer and then bind or upload the buffer. Though bind can be quite
cheap and direct as you pointed out. On those platforms I guess it is just
semantics. Direct raster is straight to the actual resource-backed canvas.
Suggestions welcome on better names.

Both - image and pixel - raster buffers support sw resource. So I thought it
might be appropriate for the direct raster buffer to support them too. There is
one slight difference - the direct path assumes 8888 config. I was hoping to use
it to implement ScopedWriteLockSoftware.
I do not know how the software resource is used by the compositor. I am assuming
the software compositor is using either IRWP or PRWP for rasterization. I will
ask @jbauman.

[reveman, 2014/02/12 17:23:40]

Each RasterWorkerPool implementation is responsible for how to throttle and
schedule tasks based on the type of interface they use for writing to a
resource.

Gpu raster was tacked on to existing RWP implementations but I think that was a
mistake. This way of writing to a resource requires a different mechanism for
throttling and that justifies a new type of RWP implementation;
"DirectRasterWorkerPool".

If we can come up with a better name later, we can change it. "Direct" is OK
with me for now.

FYI, I think we should restrict sw support to only 1 of these 3 types of writing
to a resource. Should probably be "Image" version as the throttling logic
matches what is needed for sw best.

 
-  // 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;
   };
   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* mapped_buffer_;
+    SkBitmap raster_bitmap_;
+    skia::RefPtr<SkCanvas> raster_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_