Pass ctm when performing image filtering in GPU backend.

include/core/SkMaskFilter.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 SkMaskFilter_DEFINED
@@ skipping 45 matching lines @@
         @param margin   if not null, return the buffer dx/dy need when calculating the effect. Used when
                         drawing a clipped object to know how much larger to allocate the src before
                         applying the filter. If returning false, ignore this parameter.
         @return true if the dst mask was correctly created.
     */
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const;
 
 #if SK_SUPPORT_GPU
     /**
-     *  Returns true if the filter can be expressed a single-pass
-     *  GrEffect, used to process this filter on the GPU, or false if
-     *  not.
+     *  Returns true if the filter can be expressed a single-pass GrEffect without requiring an
+     *  explicit input mask. Per-pixel, the effect receives the incoming mask's coverage as
+     *  the input color and outputs the filtered covereage value. This means that each pixel's
+     *  filtered coverage must only depend on the unfiltered mask value for that pixel and not on
+     *  surrounding values.
      *
-     *  If effect is non-NULL, a new GrEffect instance is stored
-     *  in it.  The caller assumes ownership of the stage, and it is up to the
-     *  caller to unref it.
+     * If effect is non-NULL, a new GrEffect instance is stored in it. The caller assumes ownership
+     * of the effect and must unref it.
      */
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture*) const;
+    virtual bool asNewEffect(GrEffectRef** effect,
+                             GrTexture*,
+                             const SkMatrix& ctm) const;
 
     /**
-     *  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 asNewEffect().
+     *  If asNewEffect() fails the filter may be implemented on the GPU by a subclass overriding
+     *  filterMaskGPU (declared below). That code path requires constructing a src mask as input.
+     *  Since that is a potentially expensive operation, the subclass must also override this
+     *  function to indicate whether filterTextureMaskGPU would succeeed if the mask were to be
+     *  created.
      *
-     *  'maskRect' returns the device space portion of the mask the the filter
-     *  needs. The mask passed into 'filterMaskGPU' should have the same extent
-     *  as 'maskRect' but be translated to the upper-left corner of the mask
-     *  (i.e., (maskRect.fLeft, maskRect.fTop) appears at (0, 0) in the mask).
+     *  'maskRect' returns the device space portion of the mask that the filter needs. The mask
+     *  passed into 'filterMaskGPU' should have the same extent as 'maskRect' but be translated
+     *  to the upper-left corner of the mask (i.e., (maskRect.fLeft, maskRect.fTop) appears at
+     *  (0, 0) in the mask).
      */
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
                                   const SkIRect& clipBounds,
                                   const SkMatrix& ctm,
                                   SkRect* maskRect) const;
 
     /**
-     *  Perform this mask filter 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 asNewEffect().  'src' is the
-     *  source image for processing, as a texture-backed bitmap.  'result' is
-     *  the destination bitmap, which should contain a texture-backed pixelref
-     *  on success. 'maskRect' should be the rect returned from canFilterMaskGPU.
-     */
-    bool filterMaskGPU(GrContext* context,
-                       const SkBitmap& src,
-                       const SkRect& maskRect,
-                       SkBitmap* result) const;
-
-    /**
-     *  This flavor of 'filterMaskGPU' provides a more direct means of accessing
-     *  the filtering capabilities. Setting 'canOverwriteSrc' can allow some
-     *  filters to skip the allocation of an additional texture.
+     * This function is used to implement filters that require an explicit src mask. It should only
+     * be called if canFilterMaskGPU returned true and the maskRect param should be the output from
+     * that call. canOverwriteSrc indicates whether the implementation may treat src as a scratch
+     * texture and overwrite its contents. When true it is also legal to return src as the result.
+     * Implementations are free to get the GrContext from the src texture in order to create
+     * additional textures and perform multiple passes.
      */
     virtual bool filterMaskGPU(GrTexture* src,
+                               const SkMatrix& ctm,
                                const SkRect& maskRect,
                                GrTexture** result,
                                bool canOverwriteSrc) const;
 #endif
 
     /**
      * The fast bounds function is used to enable the paint to be culled early
      * in the drawing pipeline. This function accepts the current bounds of the
      * paint as its src param and the filter adjust those bounds using its
      * current mask and returns the result using the dest param. Callers are
@@ skipping 67 matching lines @@
      to render that mask. Returns false if filterMask() returned false.
      */
     bool filterRRect(const SkRRect& devRRect, const SkMatrix& devMatrix,
                      const SkRasterClip&, SkBounder*, SkBlitter* blitter,
                      SkPaint::Style style) const;
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif