[WIP] Add Context to SkDrawLooper.

include/core/SkDrawLooper.h

 
 /*
  * Copyright 2011 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 SkDrawLooper_DEFINED
@@ skipping 12 matching lines @@
     be called, allowing it to modify the canvas and/or paint for that draw call.
     More than that, via the next() method, the looper can modify the draw to be
     invoked multiple times (hence the name loop-er), allow it to perform effects
     like shadows or frame/fills, that require more than one pass.
 */
 class SK_API SkDrawLooper : public SkFlattenable {
 public:
     SK_DECLARE_INST_COUNT(SkDrawLooper)
 
     /**
-     *  Called right before something is being drawn. This will be followed by
-     *  calls to next() until next() returns false.
+     *  Holds state during a draw. Users call next() until it returns false. The
+     *  final call to next() will also delete the context.
+     *
+     *  Subclasses of SkDrawLooper should create a subclass of this object to
+     *  hold state specific to their subclass.
      */
-    virtual void init(SkCanvas*) = 0;
+    class SK_API DrawContext {
+    public:
+        DrawContext() {}
+        virtual ~DrawContext() {}
+
+        /**
+         *  Called in a loop (after init()). Each time true is returned, the
+         *  object is drawn (possibly with a modified canvas and/or paint). When
+         *  false is finally returned, drawing for the object stops. When the
+         *  context is no longer in use, call cleanup().
+         *
+         *  On each call, the paint will be in its original state, but the
+         *  canvas will be as it was following the previous call to next() or
+         *  init().
+         *
+         *  The implementation must ensure that, when next() finally returns
+         *  false, that the canvas has been restored to the state it was
+         *  initially, before init() was first called.
+         */
+        virtual bool next(SkCanvas* canvas, SkPaint* paint) = 0;
+
+        void cleanup(void* storage);

[reed1, 2014/02/07 18:27:40]

Dox?

[Dominik Grewe, 2014/02/07 18:42:43]

Done.

+    };
 
     /**
-     *  Called in a loop (after init()). Each time true is returned, the object
-     *  is drawn (possibly with a modified canvas and/or paint). When false is
-     *  finally returned, drawing for the object stops.
+     *  Called right before something is being drawn. Returns a DrawContext
+     *  whose next() method should be called until it returns false.
      *
-     *  On each call, the paint will be in its original state, but the canvas
-     *  will be as it was following the previous call to next() or init().
-     *
-     *  The implementation must ensure that, when next() finally returns false,
-     *  that the canvas has been restored to the state it was initially, before
-     *  init() was first called.
+     *  Pass a pointer to pre-allocated memory to avoid dynamic memory
+     *  allocation.
      */
-    virtual bool next(SkCanvas*, SkPaint* paint) = 0;
+    virtual DrawContext* init(SkCanvas*, void* storage, size_t storageSize)
+        const = 0;
+
 
     /**
      * The fast bounds functions are used to enable the paint to be culled early
      * in the drawing pipeline. If a subclass can support this feature it must
      * return true for the canComputeFastBounds() function.  If that function
      * returns false then computeFastBounds behavior is undefined otherwise it
      * is expected to have the following behavior. Given the parent paint and
      * the parent's bounding rect the subclass must fill in and return the
      * storage rect, where the storage rect is with the union of the src rect
      * and the looper's bounding rect.
      */
     virtual bool canComputeFastBounds(const SkPaint& paint);
     virtual void computeFastBounds(const SkPaint& paint,
                                    const SkRect& src, SkRect* dst);
 
     SkDEVCODE(virtual void toString(SkString* str) const = 0;)
     SK_DEFINE_FLATTENABLE_TYPE(SkDrawLooper)
 
 protected:
     SkDrawLooper() {}
     SkDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     typedef SkFlattenable INHERITED;
 };
 
 #endif