WIP RasterCanvasLayerAllocator

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 15 matching lines @@
 class SkData;
 class SkDraw;
 class SkDrawable;
 class SkDrawFilter;
 class SkImageFilter;
 class SkMetaData;
 class SkPath;
 class SkPicture;
 class SkPixmap;
 class SkRasterClip;
+class SkRasterCanvasLayerAllocator;
 class SkRRect;
 struct SkRSXform;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
     This includes a reference to the device itself, and a stack of matrix/clip
@@ skipping 1166 matching lines @@
     }
 
     typedef SkCanvasClipVisitor ClipVisitor;
     /**
      *  Replays the clip operations, back to front, that have been applied to
      *  the canvas, calling the appropriate method on the visitor for each
      *  clip. All clips have already been transformed into device space.
      */
     void replayClips(ClipVisitor*) const;
 
+    /**
+     *  Returns any OS-specific native context backing this SkCanvas,
+     *  or nullptr.
+     */
+    void* getTopLayerNative() const;
+
     ///////////////////////////////////////////////////////////////////////////
 
     // don't call
     GrDrawContext* internal_private_accessTopLayerDrawContext();
 
     // don't call
     static void Internal_Private_SetIgnoreSaveLayerBounds(bool);
     static bool Internal_Private_GetIgnoreSaveLayerBounds();
     static void Internal_Private_SetTreatSpriteAsBitmap(bool);
     static bool Internal_Private_GetTreatSpriteAsBitmap();
@@ skipping 174 matching lines @@
     class MCRec;
 
     SkAutoTUnref<SkClipStack> fClipStack;
     SkDeque     fMCStack;
     // points to top of stack
     MCRec*      fMCRec;
     // the first N recs that can fit here mean we won't call malloc
     enum {
         kMCRecSize      = 128,  // most recent measurement
         kMCRecCount     = 32,   // common depth for save/restores
-        kDeviceCMSize   = 176,  // most recent measurement
+        kDeviceCMSize   = 192,  // most recent measurement
     };
     intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
     intptr_t fDeviceCMStorage[kDeviceCMSize / sizeof(intptr_t)];
 
     const SkSurfaceProps fProps;
 
     int         fSaveCount;         // value returned by getSaveCount()
 
     SkMetaData* fMetaData;
 
@@ skipping 16 matching lines @@
     friend class SkDrawIter;        // needs setupDrawForLayerDevice()
     friend class AutoDrawLooper;
     friend class SkLua;             // needs top layer size and offset
     friend class SkDebugCanvas;     // needs experimental fAllowSimplifyClip
     friend class SkSurface_Raster;  // needs getDevice()
     friend class SkRecorder;        // InitFlags
     friend class SkNoSaveLayerCanvas;   // InitFlags
     friend class SkPictureImageFilter;  // SkCanvas(SkBaseDevice*, SkSurfaceProps*, InitFlags)
     friend class SkPictureRecord;   // predrawNotify (why does it need it? <reed>)
     friend class SkPicturePlayback; // SaveFlagsToSaveLayerFlags
+    friend class SkRasterCanvasLayerAllocator;
 
     enum InitFlags {
         kDefault_InitFlags                  = 0,
         kConservativeRasterClip_InitFlag    = 1 << 0,
     };
     SkCanvas(const SkIRect& bounds, InitFlags);
     SkCanvas(SkBaseDevice* device, InitFlags);
+    SkCanvas(const SkBitmap& bitmap, sk_sp<SkRasterCanvasLayerAllocator>);

[tomhudson, 2016/05/26 16:36:17]

Figuring out lifetime here is a little awkward - the RasterCanvasLayerAllocator
constructs a smart pointer around (this) to pass here so that the Canvas can own
it?

Perhaps we should instead copy in the Allocator, since we really don't want to
have one instance shared between multiple canvases. That is itself awkward to
code, although we can hide the awkwardness from the API user I *think*.

Or perhaps that's not so important, and we can share these; if we don't share
these, we could simplify the API a bit.

[reed1, 2016/07/12 19:52:39]

I think unique_ptr as a parameter type is fine. No need to make it sharable (at
least not right now).

 
     void resetForNextPicture(const SkIRect& bounds);
 
     // needs gettotalclip()
     friend class SkCanvasStateUtils;
 
     // call this each time we attach ourselves to a device
     //  - constructor
     //  - internalSaveLayer
     void setupDevice(SkBaseDevice*);
 
-    SkBaseDevice* init(SkBaseDevice*, InitFlags);
+    SkBaseDevice* init(SkBaseDevice*, InitFlags, sk_sp<SkRasterCanvasLayerAllocator>);
 
     /**
      * Gets the bounds of the top level layer in global canvas coordinates. We don't want this
      * to be public because it exposes decisions about layer sizes that are internal to the canvas.
      */
     SkIRect getTopLayerBounds() const;
 
     void internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                                 const SkRect& dst, const SkPaint* paint,
                                 SrcRectConstraint);
@@ skipping 54 matching lines @@
     private:
         const SkCanvas* fCanvas;
     };
 
 #ifdef SK_DEBUG
     void validateClip() const;
 #else
     void validateClip() const {}
 #endif
 
+    sk_sp<SkRasterCanvasLayerAllocator> fAllocator;
+
     typedef SkRefCnt INHERITED;
 };
 
 /** Stack helper class to automatically call restoreToCount() on the canvas
     when this object goes out of scope. Use this to guarantee that the canvas
     is restored to a known state.
 */
 class SkAutoCanvasRestore : SkNoncopyable {
 public:
     SkAutoCanvasRestore(SkCanvas* canvas, bool doSave) : fCanvas(canvas), fSaveCount(0) {
@@ skipping 29 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif