WIP RasterCanvasLayerAllocator experiment 2

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
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkImage.h"
 #include "SkPaint.h"
+#include "SkRasterCanvasLayerAllocator.h"
 #include "SkRefCnt.h"
 #include "SkRegion.h"
 #include "SkSurfaceProps.h"
 #include "SkXfermode.h"
 #include "SkLights.h"
 #include "../private/SkShadowParams.h"
 
 class GrContext;
 class GrDrawContext;
 class SkBaseDevice;
@@ skipping 69 matching lines @@
      *  the draw calls in some other way.
      */
     SkCanvas(int width, int height, const SkSurfaceProps* = NULL);
 
     /** Construct a canvas with the specified device to draw into.
 
         @param device   Specifies a device for the canvas to draw into.
     */
     explicit SkCanvas(SkBaseDevice* device);
 
+    explicit SkCanvas(SkBaseDevice* device, SkRasterCanvasLayerAllocator*);
+
     /** Construct a canvas with the specified bitmap to draw into.
         @param bitmap   Specifies a bitmap for the canvas to draw into. Its
                         structure are copied to the canvas.
     */
     explicit SkCanvas(const SkBitmap& bitmap);
 
     /** Construct a canvas with the specified bitmap to draw into.
         @param bitmap   Specifies a bitmap for the canvas to draw into. Its
                         structure are copied to the canvas.
         @param props    New canvas surface properties.
@@ skipping 10 matching lines @@
      */
     SkImageInfo imageInfo() const;
 
     /**
      *  If the canvas is backed by pixels (cpu or gpu), this writes a copy of the SurfaceProps
      *  for the canvas to the location supplied by the caller, and returns true. Otherwise,
      *  return false and leave the supplied props unchanged.
      */
     bool getProps(SkSurfaceProps*) const;
 
+    SkRasterCanvasLayerAllocator* getLayerAllocator() const { return fLayerAllocator.get(); }
+
     ///////////////////////////////////////////////////////////////////////////
 
     /**
      *  Trigger the immediate execution of all pending draw operations. For the GPU
      *  backend this will resolve all rendering to the GPU surface backing the
      *  SkSurface that owns this canvas.
      */
     void flush();
 
     /**
@@ skipping 1537 matching lines @@
     private:
         const SkCanvas* fCanvas;
     };
 
 #ifdef SK_DEBUG
     void validateClip() const;
 #else
     void validateClip() const {}
 #endif
 
+    std::unique_ptr<SkRasterCanvasLayerAllocator> fLayerAllocator;
+
     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