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 14 matching lines @@
 class SkClipStack;
 class SkData;
 class SkDraw;
 class SkDrawable;
 class SkDrawFilter;
 class SkImageFilter;
 class SkMetaData;
 class SkPath;
 class SkPicture;
 class SkPixmap;
+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 1141 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;
+
     ///////////////////////////////////////////////////////////////////////////
 
     /** After calling saveLayer(), there can be any number of devices that make
         up the top-most drawing area. LayerIter can be used to iterate through
         those devices. Note that the iterator is only valid until the next API
         call made on the canvas. Ownership of all pointers in the iterator stays
         with the canvas, so none of them should be modified or deleted.
     */
     class SK_API LayerIter /*: SkNoncopyable*/ {
     public:
@@ skipping 168 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   = 136,  // most recent measurement
+        kDeviceCMSize   = 152,  // 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 107 matching lines @@
     private:
         const SkCanvas* fCanvas;
     };
 
 #ifdef SK_DEBUG
     void validateClip() const;
 #else
     void validateClip() const {}
 #endif
 
+    SkRasterCanvasLayerAllocator* fAllocator;

[reed1, 2016/05/11 18:58:24]

I presume we'll add a constructor that takes an allocator?

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

With the next patchset, I'm proposing a factory on an allocator that wires the
allocator into the canvas it constructs.

+
     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