use conics for addRRect

src/core/SkPath.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 "SkBuffer.h"
 #include "SkErrorInternals.h"
 #include "SkGeometry.h"
 #include "SkMath.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
 #include "SkRRect.h"
 #include "SkThread.h"
 
+// These two should be removed once we fix any gpu bugs, and then
+// just move them into skia_for_chromium_defines.gypi
 #define SK_SUPPORT_LEGACY_ADDOVAL
+#define SK_SUPPORT_LEGACY_ADDRRECT
 
 ////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Path.bounds is defined to be the bounds of all the control points.
  *  If we called bounds.join(r) we would skip r if r was empty, which breaks
  *  our promise. Hence we have a custom joiner that doesn't look at emptiness
  */
 static void joinNoEmptyChecks(SkRect* dst, const SkRect& src) {
     dst->fLeft = SkMinScalar(dst->fLeft, src.fLeft);
@@ skipping 935 matching lines @@
                           &matrix, pts);
 }
 
 void SkPath::addRoundRect(const SkRect& rect, const SkScalar radii[],
                           Direction dir) {
     SkRRect rrect;
     rrect.setRectRadii(rect, (const SkVector*) radii);
     this->addRRect(rrect, dir);
 }
 
+#ifdef SK_SUPPORT_LEGACY_ADDRRECT
 /* The inline clockwise and counterclockwise round rect quad approximations
    make it easier to see the symmetry patterns used by add corner quads.
 Clockwise                                                     corner value
     path->lineTo(rect.fLeft,           rect.fTop    + ry);    0 upper left
     path->quadTo(rect.fLeft,           rect.fTop    + offPtY,
                  rect.fLeft  + midPtX, rect.fTop    + midPtY);
     path->quadTo(rect.fLeft  + offPtX, rect.fTop,
                  rect.fLeft  + rx,     rect.fTop);
 
     path->lineTo(rect.fRight - rx,     rect.fTop);            1 upper right
@@ skipping 106 matching lines @@
         path->lineTo(xOff[0], yOff[0]);
     }
     if (rx || ry) {
         path->quadTo(xOff[1], yOff[1], xOff[2], yOff[2]);
         path->quadTo(xOff[3], yOff[3], xOff[4], yOff[4]);
     } else {
         path->lineTo(xOff[2], yOff[2]);
         path->lineTo(xOff[4], yOff[4]);
     }
 }
+#endif
 
 void SkPath::addRRect(const SkRRect& rrect, Direction dir) {
     assert_known_direction(dir);
 
     if (rrect.isEmpty()) {
         return;
     }
 
     const SkRect& bounds = rrect.getBounds();
 
     if (rrect.isRect()) {
         this->addRect(bounds, dir);
     } else if (rrect.isOval()) {
         this->addOval(bounds, dir);
     } else {
         fDirection = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
 
         SkAutoPathBoundsUpdate apbu(this, bounds);
         SkAutoDisableDirectionCheck addc(this);
 
+#ifdef SK_SUPPORT_LEGACY_ADDRRECT
         this->incReserve(21);
         if (kCW_Direction == dir) {
             this->moveTo(bounds.fLeft,
                          bounds.fBottom - rrect.fRadii[SkRRect::kLowerLeft_Corner].fY);
             add_corner_quads(this, rrect, SkRRect::kUpperLeft_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerLeft_Corner, dir);
         } else {
             this->moveTo(bounds.fLeft,
                          bounds.fTop + rrect.fRadii[SkRRect::kUpperLeft_Corner].fY);
             add_corner_quads(this, rrect, SkRRect::kLowerLeft_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperLeft_Corner, dir);
         }
+#else
+        const SkScalar L = bounds.fLeft;
+        const SkScalar T = bounds.fTop;
+        const SkScalar R = bounds.fRight;
+        const SkScalar B = bounds.fBottom;
+        const SkScalar W = SK_ScalarRoot2Over2;
+
+        this->incReserve(13);
+        if (kCW_Direction == dir) {
+            this->moveTo(L, B - rrect.fRadii[SkRRect::kLowerLeft_Corner].fY);
+
+            this->lineTo(L, T + rrect.fRadii[SkRRect::kUpperLeft_Corner].fY);
+            this->conicTo(L, T, L + rrect.fRadii[SkRRect::kUpperLeft_Corner].fX, T, W);
+
+            this->lineTo(R - rrect.fRadii[SkRRect::kUpperRight_Corner].fX, T);
+            this->conicTo(R, T, R, T + rrect.fRadii[SkRRect::kUpperRight_Corner].fY, W);
+
+            this->lineTo(R, B - rrect.fRadii[SkRRect::kLowerRight_Corner].fY);
+            this->conicTo(R, B, R - rrect.fRadii[SkRRect::kLowerRight_Corner].fX, B, W);
+
+            this->lineTo(L + rrect.fRadii[SkRRect::kLowerLeft_Corner].fX, B);
+            this->conicTo(L, B, L, B - rrect.fRadii[SkRRect::kLowerLeft_Corner].fY, W);
+        } else {
+            this->moveTo(L, T + rrect.fRadii[SkRRect::kUpperLeft_Corner].fY);
+
+            this->lineTo(L, B - rrect.fRadii[SkRRect::kLowerLeft_Corner].fY);
+            this->conicTo(L, B, L + rrect.fRadii[SkRRect::kLowerLeft_Corner].fX, B, W);
+
+            this->lineTo(R - rrect.fRadii[SkRRect::kLowerRight_Corner].fX, B);
+            this->conicTo(R, B, R, B - rrect.fRadii[SkRRect::kLowerRight_Corner].fY, W);
+
+            this->lineTo(R, T + rrect.fRadii[SkRRect::kUpperRight_Corner].fY);
+            this->conicTo(R, T, R - rrect.fRadii[SkRRect::kUpperRight_Corner].fX, T, W);
+
+            this->lineTo(L + rrect.fRadii[SkRRect::kUpperLeft_Corner].fX, T);
+            this->conicTo(L, T, L, T + rrect.fRadii[SkRRect::kUpperLeft_Corner].fY, W);
+        }
+#endif
         this->close();
     }
     SkDEBUGCODE(fPathRef->validate();)
 }
 
 bool SkPath::hasOnlyMoveTos() const {
     int count = fPathRef->countVerbs();
     const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbsMemBegin();
     for (int i = 0; i < count; ++i) {
         if (*verbs == kLine_Verb ||
@@ skipping 1749 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }