Add ability to ninepatch blurred rounded rectangle

src/core/SkMaskFilter.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkMaskFilter.h"
 #include "SkBlitter.h"
 #include "SkBounder.h"
 #include "SkDraw.h"
 #include "SkRasterClip.h"
+#include "SkRRect.h"
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 #include "SkGr.h"
 #include "SkGrPixelRef.h"
 #endif
 
 SK_DEFINE_INST_COUNT(SkMaskFilter)
 
@@ skipping 172 matching lines @@
     }
 }
 
 static int countNestedRects(const SkPath& path, SkRect rects[2]) {
     if (path.isNestedRects(rects)) {
         return 2;
     }
     return path.isRect(&rects[0]);
 }
 
+bool SkMaskFilter::filterRRect(const SkRRect& devRRect, const SkMatrix& matrix,
+                               const SkRasterClip& clip, SkBounder* bounder,
+                               SkBlitter* blitter, SkPaint::Style style) const {

[robertphillips, 2013/10/31 00:24:58]

Could you expand on what makes this case sneaky?

[scroggo, 2013/11/01 21:45:46]

Done.

+    // Only handle the sneaky case:
+    NinePatch patch;
+    patch.fMask.fImage = NULL;
+    if (kTrue_FilterReturn != this->filterRRectToNine(devRRect, matrix,
+                                                      clip.getBounds(),
+                                                      &patch)) {
+        return false;
+    }
+    draw_nine(patch.fMask, patch.fOuterRect, patch.fCenter, true, clip,
+              bounder, blitter);
+    SkMask::FreeImage(patch.fMask.fImage);
+    return true;
+}
+
 bool SkMaskFilter::filterPath(const SkPath& devPath, const SkMatrix& matrix,
                               const SkRasterClip& clip, SkBounder* bounder,
                               SkBlitter* blitter, SkPaint::Style style) const {
     SkRect rects[2];
     int rectCount = 0;
     if (SkPaint::kFill_Style == style) {
         rectCount = countNestedRects(devPath, rects);
     }
     if (rectCount > 0) {
         NinePatch patch;
@@ skipping 43 matching lines @@
         do {
             blitter->blitMask(dstM, cr);
             clipper.next();
         } while (!clipper.done());
     }
 
     return true;
 }
 
 SkMaskFilter::FilterReturn
+SkMaskFilter::filterRRectToNine(const SkRRect&, const SkMatrix&,
+                                const SkIRect& clipBounds, NinePatch*) const {
+    return kUnimplemented_FilterReturn;
+}
+
+SkMaskFilter::FilterReturn
 SkMaskFilter::filterRectsToNine(const SkRect[], int count, const SkMatrix&,
                                 const SkIRect& clipBounds, NinePatch*) const {
     return kUnimplemented_FilterReturn;
 }
 
 #if SK_SUPPORT_GPU
 bool SkMaskFilter::asNewEffect(GrEffectRef** effect, GrTexture*) const {
     return false;
 }
 
@@ skipping 67 matching lines @@
     srcM.fRowBytes = 0;
     srcM.fFormat = SkMask::kA8_Format;
 
     SkIPoint margin;    // ignored
     if (this->filterMask(&dstM, srcM, SkMatrix::I(), &margin)) {
         dst->set(dstM.fBounds);
     } else {
         dst->set(srcM.fBounds);
     }
 }