patch from issue 119343003

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
 #define SkMaskFilter_DEFINED
 
 #include "SkFlattenable.h"
 #include "SkMask.h"
 #include "SkPaint.h"
 
 class GrContext;
+class GrPaint;
 class SkBitmap;
 class SkBlitter;
 class SkBounder;
 class SkMatrix;
 class SkPath;
 class SkRasterClip;
 class SkRRect;
+class SkStrokeRec;
 
 /** \class SkMaskFilter
 
     SkMaskFilter is the base class for object that perform transformations on
     an alpha-channel mask before drawing it. A subclass of SkMaskFilter may be
     installed into a SkPaint. Once there, each time a primitive is drawn, it
     is first scan converted into a SkMask::kA8_Format mask, and handed to the
     filter, calling its filterMask() method. If this returns true, then the
     new mask is used to render into the device.
 
@@ skipping 52 matching lines @@
      *  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;
 
     /**
+     *  Try to directly render the mask filter into the target.  Returns
+     *  true if drawing was successful.
+     */
+    virtual bool directFilterMaskGPU(GrContext* context,
+                                     GrPaint* grp,
+                                     const SkStrokeRec& strokeRec,
+                                     const SkPath& path) const;
+
+    /**
      * 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,
@@ skipping 76 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