Remove SK_SUPPORT_LEGACY_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"
@@ skipping 957 matching lines @@
 }
 #endif
 
 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
-    path->quadTo(rect.fRight - offPtX, rect.fTop,
-                 rect.fRight - midPtX, rect.fTop    + midPtY);
-    path->quadTo(rect.fRight,          rect.fTop    + offPtY,
-                 rect.fRight,          rect.fTop    + ry);
-
-    path->lineTo(rect.fRight,          rect.fBottom - ry);    2 lower right
-    path->quadTo(rect.fRight,          rect.fBottom - offPtY,
-                 rect.fRight - midPtX, rect.fBottom - midPtY);
-    path->quadTo(rect.fRight - offPtX, rect.fBottom,
-                 rect.fRight - rx,     rect.fBottom);
-
-    path->lineTo(rect.fLeft  + rx,     rect.fBottom);         3 lower left
-    path->quadTo(rect.fLeft  + offPtX, rect.fBottom,
-                 rect.fLeft  + midPtX, rect.fBottom - midPtY);
-    path->quadTo(rect.fLeft,           rect.fBottom - offPtY,
-                 rect.fLeft,           rect.fBottom - ry);
-
-Counterclockwise
-    path->lineTo(rect.fLeft,           rect.fBottom - ry);    3 lower left
-    path->quadTo(rect.fLeft,           rect.fBottom - offPtY,
-                 rect.fLeft  + midPtX, rect.fBottom - midPtY);
-    path->quadTo(rect.fLeft  + offPtX, rect.fBottom,
-                 rect.fLeft  + rx,     rect.fBottom);
-
-    path->lineTo(rect.fRight - rx,     rect.fBottom);         2 lower right
-    path->quadTo(rect.fRight - offPtX, rect.fBottom,
-                 rect.fRight - midPtX, rect.fBottom - midPtY);
-    path->quadTo(rect.fRight,          rect.fBottom - offPtY,
-                 rect.fRight,          rect.fBottom - ry);
-
-    path->lineTo(rect.fRight,          rect.fTop    + ry);    1 upper right
-    path->quadTo(rect.fRight,          rect.fTop    + offPtY,
-                 rect.fRight - midPtX, rect.fTop    + midPtY);
-    path->quadTo(rect.fRight - offPtX, rect.fTop,
-                 rect.fRight - rx,     rect.fTop);
-
-    path->lineTo(rect.fLeft  + rx,     rect.fTop);            0 upper left
-    path->quadTo(rect.fLeft  + offPtX, rect.fTop,
-                 rect.fLeft  + midPtX, rect.fTop    + midPtY);
-    path->quadTo(rect.fLeft,           rect.fTop    + offPtY,
-                 rect.fLeft,           rect.fTop    + ry);
-*/
-static void add_corner_quads(SkPath* path, const SkRRect& rrect,
-                             SkRRect::Corner corner, SkPath::Direction dir) {
-    const SkRect& rect = rrect.rect();
-    const SkVector& radii = rrect.radii(corner);
-    SkScalar rx = radii.fX;
-    SkScalar ry = radii.fY;
-    // The mid point of the quadratic arc approximation is half way between the two
-    // control points.
-    const SkScalar mid = 1 - (SK_Scalar1 + SK_ScalarTanPIOver8) / 2;
-    SkScalar midPtX = rx * mid;
-    SkScalar midPtY = ry * mid;
-    const SkScalar control = 1 - SK_ScalarTanPIOver8;
-    SkScalar offPtX = rx * control;
-    SkScalar offPtY = ry * control;
-    static const int kCornerPts = 5;
-    SkScalar xOff[kCornerPts];
-    SkScalar yOff[kCornerPts];
-
-    if ((corner & 1) == (dir == SkPath::kCCW_Direction)) {  // corners always alternate direction
-        SkASSERT(dir == SkPath::kCCW_Direction
-             ? corner == SkRRect::kLowerLeft_Corner || corner == SkRRect::kUpperRight_Corner
-             : corner == SkRRect::kUpperLeft_Corner || corner == SkRRect::kLowerRight_Corner);
-        xOff[0] = xOff[1] = 0;
-        xOff[2] = midPtX;
-        xOff[3] = offPtX;
-        xOff[4] = rx;
-        yOff[0] = ry;
-        yOff[1] = offPtY;
-        yOff[2] = midPtY;
-        yOff[3] = yOff[4] = 0;
-    } else {
-        xOff[0] = rx;
-        xOff[1] = offPtX;
-        xOff[2] = midPtX;
-        xOff[3] = xOff[4] = 0;
-        yOff[0] = yOff[1] = 0;
-        yOff[2] = midPtY;
-        yOff[3] = offPtY;
-        yOff[4] = ry;
-    }
-    if ((corner - 1) & 2) {
-        SkASSERT(corner == SkRRect::kLowerLeft_Corner || corner == SkRRect::kUpperLeft_Corner);
-        for (int i = 0; i < kCornerPts; ++i) {
-            xOff[i] = rect.fLeft + xOff[i];
-        }
-    } else {
-        SkASSERT(corner == SkRRect::kLowerRight_Corner || corner == SkRRect::kUpperRight_Corner);
-        for (int i = 0; i < kCornerPts; ++i) {
-            xOff[i] = rect.fRight - xOff[i];
-        }
-    }
-    if (corner < SkRRect::kLowerRight_Corner) {
-        for (int i = 0; i < kCornerPts; ++i) {
-            yOff[i] = rect.fTop + yOff[i];
-        }
-    } else {
-        for (int i = 0; i < kCornerPts; ++i) {
-            yOff[i] = rect.fBottom - yOff[i];
-        }
-    }
-
-    SkPoint lastPt;
-    SkAssertResult(path->getLastPt(&lastPt));
-    if (lastPt.fX != xOff[0] || lastPt.fY != yOff[0]) {
-        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);
 
@@ skipping 16 matching lines @@
 
             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 1754 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }