[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.
+     *  When the context is no longer needed, call cleanup() to ensure memory

[scroggo, 2014/03/11 14:08:05]

No need for comment about cleanup()

[Dominik Grewe, 2014/03/11 18:28:17]

Done.

+     *  is released correctly.
+     *
+     *  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 Context : public SkNoncopyable {
+    public:
+        Context() {}
+        virtual ~Context() {}
+
+        /**
+         *  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.
+         *
+         *  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;
+    };
 
     /**
-     *  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.
-     *
-     *  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.
+     *  Called right before something is being drawn. Returns a Context
+     *  whose next() method should be called until it returns false.
+     *  The caller has to ensure that the storage pointer provides enough
+     *  memory for the Context. The required size can be queried by calling
+     *  contextSize(). It is also the caller's responsibility to destroy the
+     *  object after use.
      */
-    virtual bool next(SkCanvas*, SkPaint* paint) = 0;
+    virtual Context* init(SkCanvas*, void* storage) const = 0;

[reed1, 2014/03/11 14:23:31]

Rename to something that reflects its "factory" nature? newContext(...),
createContext(...)?

Did you consider passing the size as well, just for debugging/security reasons?

... size_t sizeOfStorage)

[scroggo, 2014/03/11 15:51:02]

Personally I like not having the size there. Passing the size gives the
impression that the size might not be big enough, so we have to potentially
handle that case separately.

(It's also not really a guarantee - someone could call this function with a
different size than they actually provided. Granted, it does give us the
opportunity to SkASSERT that the size is big enough.)

[Dominik Grewe, 2014/03/11 18:28:17]

Done.
As scroggo@ suggested, I'm not passing the size here.

+
+    /**
+      *  Returns the number of bytes needed to store a Context object.

[scroggo, 2014/03/11 14:08:05]

I think it might be clearer to state that this is the number of bytes needed to
store the subclass's subclass of Context

[Dominik Grewe, 2014/03/11 18:28:17]

Done.

+      */
+    virtual size_t contextSize() 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);

[reed1, 2014/03/11 14:23:31]

What is the plan for these? Will they become const?

[Dominik Grewe, 2014/03/11 18:28:17]

Good point. Yes, they can now be const.

     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