Avoid devolving to a path when conservative clipping with RRects

src/core/SkRasterClip.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRasterClip.h"
 #include "SkPath.h"
 
@@ skipping 143 matching lines @@
         // TODO: since we are going to over-write fAA completely (aren't we?)
         // we should just clear our BW data (if any) and set fIsAA=true
         if (this->isBW()) {
             this->convertToAA();
         }
         (void)fAA.setPath(path, &clip, doAA);
     }
     return this->updateCacheAndReturnNonEmpty();
 }
 
+bool SkRasterClip::op(const SkRRect& rrect, const SkISize& size, SkRegion::Op op, bool doAA) {
+    if (fForceConservativeRects) {
+        return this->op(rrect.getBounds(), size, op, doAA);
+    }
+
+    SkPath path;
+    path.addRRect(rrect);
+
+    return this->op(path, size, op, doAA);
+}
+
 bool SkRasterClip::op(const SkPath& path, const SkISize& size, SkRegion::Op op, bool doAA) {
-    // base is used to limit the size (and therefore memory allocation) of the
-    // region that results from scan converting devPath.
-    SkRegion base;
+    AUTO_RASTERCLIP_VALIDATE(*this);
 
     if (fForceConservativeRects) {
         SkIRect ir;
         switch (mutate_conservative_op(&op, path.isInverseFillType())) {
             case kDoNothing_MutateResult:
                 return !this->isEmpty();
             case kReplaceClippedAgainstGlobalBounds_MutateResult:
                 ir = SkIRect::MakeSize(size);
                 break;
             case kContinue_MutateResult:
                 ir = path.getBounds().roundOut();
                 break;
         }
         return this->op(ir, op);
     }
 
+    // base is used to limit the size (and therefore memory allocation) of the
+    // region that results from scan converting devPath.
+    SkRegion base;
+
     if (SkRegion::kIntersect_Op == op) {
         // since we are intersect, we can do better (tighter) with currRgn's
         // bounds, than just using the device. However, if currRgn is complex,
         // our region blitter may hork, so we do that case in two steps.
         if (this->isRect()) {
             // FIXME: we should also be able to do this when this->isBW(),
             // but relaxing the test above triggers GM asserts in
             // SkRgnBuilder::blitH(). We need to investigate what's going on.
             return this->setPath(path, this->bwRgn(), doAA);
         } else {
@@ skipping 219 matching lines @@
         fBlitter = blitter;
     } else {
         const SkAAClip& aaclip = clip.aaRgn();
         fBWRgn.setRect(aaclip.getBounds());
         fAABlitter.init(blitter, &aaclip);
         // now our return values
         fClipRgn = &fBWRgn;
         fBlitter = &fAABlitter;
     }
 }