Change signatures of filter bounds methods to return a rect.

include/core/SkImageFilter.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageFilter_DEFINED
 #define SkImageFilter_DEFINED
 
@@ skipping 146 matching lines @@
         kReverse_MapDirection
     };
     /**
      * Map a device-space rect recursively forward or backward through the
      * filter DAG. kForward_MapDirection is used to determine which pixels of
      * the destination canvas a source image rect would touch after filtering.
      * kReverse_MapDirection is used to determine which rect of the source
      * image would be required to fill the given rect (typically, clip bounds).
      * Used for clipping and temp-buffer allocations, so the result need not
      * be exact, but should never be smaller than the real answer. The default
-     * implementation recursively unions all input bounds, or returns false if
-     * no inputs.
+     * implementation recursively unions all input bounds, or returns the
+     * source rect if no inputs.
      */
+    SkIRect filterBounds(const SkIRect& src, const SkMatrix& ctm,
+                         MapDirection = kReverse_MapDirection) const;
+
+#ifdef SK_SUPPORT_LEGACY_FILTERBOUNDS_RETURN
+    /* DEPRECATED */
     bool filterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst,
                       MapDirection = kReverse_MapDirection) const;
+#endif
 
     /**
      *  Returns true if the filter can be processed on the GPU.  This is most
      *  often used for multi-pass effects, where intermediate results must be
      *  rendered to textures.  For single-pass effects, use asFragmentProcessor().
      *  The default implementation returns asFragmentProcessor(NULL, NULL, SkMatrix::I(),
      *  SkIRect()).
      */
     virtual bool canFilterImageGPU() const;
 
@@ skipping 57 matching lines @@
      *  should be used to offset access to the input images, and should also
      *  be added to the "offset" parameter in onFilterImage and
      *  filterImageGPU(). (The latter ensures that the resulting buffer is
      *  drawn in the correct location.)
      */
     bool cropRectIsSet() const { return fCropRect.flags() != 0x0; }
 
     CropRect getCropRect() const { return fCropRect; }
 
     // Default impl returns union of all input bounds.
-    virtual void computeFastBounds(const SkRect&, SkRect*) const;
+    virtual SkRect computeFastBounds(const SkRect&) const;

[reed1, 2016/03/21 20:44:32]

hope nobody in chrome/blink called this

[Stephen White, 2016/03/21 20:47:03]

Nope. I git grepped, and built Chrome to be sure. :)

 
     // Can this filter DAG compute the resulting bounds of an object-space rectangle?
     virtual bool canComputeFastBounds() const;
 
     /**
      *  If this filter can be represented by another filter + a localMatrix, return that filter,
      *  else return null.
      */
     SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const;
 
@@ skipping 91 matching lines @@
      *  case both the result and offset parameters will be ignored by the
      *  caller.
      */
     virtual bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                          SkBitmap* result, SkIPoint* offset) const;
 
     virtual SkSpecialImage* onFilterImage(SkSpecialImage* src, const Context&,
                                           SkIPoint* offset) const;
 
     /**
-     * This function recurses into its inputs with the given clip rect (first
+     * This function recurses into its inputs with the given rect (first
      * argument), calls filterBounds() with the given map direction on each,
-     * and unions the result (third argument). If the rect cannot be mapped,
-     * false is returned and the destination rect is left unchanged.
-     * If a derived class has special recursion requirements (e.g., it has an
-     * input which does not participate in bounds computation), it can be
-     * overridden here.
+     * and returns the union of those results. If a derived class has special
+     * recursion requirements (e.g., it has an input which does not participate
+     * in bounds computation), it can be overridden here.
      *
      * Note that this function is *not* responsible for mapping the rect for
      * this node's filter bounds requirements (i.e., calling
      * onFilterNodeBounds()); that is handled by filterBounds().
      */
-    virtual bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*, MapDirection) const;
+    virtual SkIRect onFilterBounds(const SkIRect&, const SkMatrix&, MapDirection) const;
 
     /**
      * Performs a forwards or reverse mapping of the given rect to accommodate
      * this filter's margin requirements. kForward_MapDirection is used to
      * determine the destination pixels which would be touched by filtering
      * the given given source rect (e.g., given source bitmap bounds,
      * determine the optimal bounds of the filtered offscreen bitmap).
      * kReverse_MapDirection is used to determine which pixels of the
      * input(s) would be required to fill the given destination rect
      * (e.g., clip bounds). NOTE: these operations may not be the
      * inverse of the other. For example, blurring expands the given rect
      * in both forward and reverse directions. Unlike
      * onFilterBounds(), this function is non-recursive.
      */
-    virtual void onFilterNodeBounds(const SkIRect&, const SkMatrix&, SkIRect*, MapDirection) const;
+    virtual SkIRect onFilterNodeBounds(const SkIRect&, const SkMatrix&, MapDirection) const;
 
     // Helper function which invokes filter processing on the input at the
     // specified "index". If the input is null, it leaves "result" and
     // "offset" untouched, and returns true. If the input is non-null, it
     // calls filterImage() on that input, and returns true on success.
     // i.e., return !getInput(index) || getInput(index)->filterImage(...);
     bool filterInputDeprecated(int index, Proxy*, const SkBitmap& src, const Context&,
                                SkBitmap* result, SkIPoint* offset) const;
 
     /**
@@ skipping 80 matching lines @@
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif