Revert of Add flipped gradient branch to two point conical gradient

src/effects/gradients/SkTwoPointConicalGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointConicalGradient.h"
 
 #include "SkTwoPointConicalGradient_gpu.h"
@@ skipping 14 matching lines @@
     SkASSERT(ratio);
     if (0 == denom) {
         return 0;
     }
     *ratio = numer / denom;
     return 1;
 }
 
 // Return the number of distinct real roots, and write them into roots[] in
 // ascending order
-static int find_quad_roots(float A, float B, float C, float roots[2], bool descendingOrder = false) {
+static int find_quad_roots(float A, float B, float C, float roots[2]) {
     SkASSERT(roots);
 
     if (A == 0) {
         return valid_divide(-C, B, roots);
     }
 
     float R = B*B - 4*A*C;
     if (R < 0) {
         return 0;
     }
@@ skipping 13 matching lines @@
     Q *= -0.5f;
     if (0 == Q) {
         roots[0] = 0;
         return 1;
     }
 
     float r0 = Q / A;
     float r1 = C / Q;
     roots[0] = r0 < r1 ? r0 : r1;
     roots[1] = r0 > r1 ? r0 : r1;
-    if (descendingOrder) {
-        SkTSwap(roots[0], roots[1]);
-    }
     return 2;
 }
 
 static float lerp(float x, float dx, float t) {
     return x + t * dx;
 }
 
 static float sqr(float x) { return x * x; }
 
 void TwoPtRadial::init(const SkPoint& center0, SkScalar rad0,
-                       const SkPoint& center1, SkScalar rad1,
-                       bool flipped) {
+                       const SkPoint& center1, SkScalar rad1) {
     fCenterX = SkScalarToFloat(center0.fX);
     fCenterY = SkScalarToFloat(center0.fY);
     fDCenterX = SkScalarToFloat(center1.fX) - fCenterX;
     fDCenterY = SkScalarToFloat(center1.fY) - fCenterY;
     fRadius = SkScalarToFloat(rad0);
     fDRadius = SkScalarToFloat(rad1) - fRadius;
 
     fA = sqr(fDCenterX) + sqr(fDCenterY) - sqr(fDRadius);
     fRadius2 = sqr(fRadius);
     fRDR = fRadius * fDRadius;
-
-    fFlipped = flipped;
 }
 
 TwoPtRadialContext::TwoPtRadialContext(const TwoPtRadial& rec, SkScalar fx, SkScalar fy,
                                        SkScalar dfx, SkScalar dfy)
     : fRec(rec)
     , fRelX(SkScalarToFloat(fx) - rec.fCenterX)
     , fRelY(SkScalarToFloat(fy) - rec.fCenterY)
     , fIncX(SkScalarToFloat(dfx))
     , fIncY(SkScalarToFloat(dfy))
     , fB(-2 * (rec.fDCenterX * fRelX + rec.fDCenterY * fRelY + rec.fRDR))
     , fDB(-2 * (rec.fDCenterX * fIncX + rec.fDCenterY * fIncY)) {}
 
 SkFixed TwoPtRadialContext::nextT() {
     float roots[2];
 
     float C = sqr(fRelX) + sqr(fRelY) - fRec.fRadius2;
-    int countRoots = find_quad_roots(fRec.fA, fB, C, roots, fRec.fFlipped);
+    int countRoots = find_quad_roots(fRec.fA, fB, C, roots);
 
     fRelX += fIncX;
     fRelY += fIncY;
     fB += fDB;
 
     if (0 == countRoots) {
         return TwoPtRadial::kDontDrawT;
     }
 
     // Prefer the bigger t value if both give a radius(t) > 0
@@ skipping 58 matching lines @@
             SkFixed index = mirror_tileproc(t);
             SkASSERT(index <= 0xFFFF);
             *dstC++ = cache[toggle +
                             (index >> SkGradientShaderBase::kCache32Shift)];
         }
         toggle = next_dither_toggle(toggle);
     }
 }
 
 void SkTwoPointConicalGradient::init() {
-    fRec.init(fCenter1, fRadius1, fCenter2, fRadius2, fFlippedGrad);
+    fRec.init(fCenter1, fRadius1, fCenter2, fRadius2);
     fPtsToUnit.reset();
 }
 
 /////////////////////////////////////////////////////////////////////
 
 SkTwoPointConicalGradient::SkTwoPointConicalGradient(
         const SkPoint& start, SkScalar startRadius,
         const SkPoint& end, SkScalar endRadius,
-        bool flippedGrad, const Descriptor& desc)
+        const Descriptor& desc)
     : SkGradientShaderBase(desc),
     fCenter1(start),
     fCenter2(end),
     fRadius1(startRadius),
-    fRadius2(endRadius),
-    fFlippedGrad(flippedGrad) {
+    fRadius2(endRadius) {
     // this is degenerate, and should be caught by our caller
     SkASSERT(fCenter1 != fCenter2 || fRadius1 != fRadius2);
     this->init();
 }
 
 bool SkTwoPointConicalGradient::isOpaque() const {
     // Because areas outside the cone are left untouched, we cannot treat the
     // shader as opaque even if the gradient itself is opaque.
     // TODO(junov): Compute whether the cone fills the plane crbug.com/222380
     return false;
@@ skipping 128 matching lines @@
     return kConical_GradientType;
 }
 
 SkTwoPointConicalGradient::SkTwoPointConicalGradient(
     SkReadBuffer& buffer)
     : INHERITED(buffer),
     fCenter1(buffer.readPoint()),
     fCenter2(buffer.readPoint()),
     fRadius1(buffer.readScalar()),
     fRadius2(buffer.readScalar()) {
-    if (buffer.pictureVersion() >= 24 || 0 == buffer.pictureVersion()) {
-        fFlippedGrad = buffer.readBool();
-    } else {
-        // V23_COMPATIBILITY_CODE
-        // Sort gradient by radius size for old pictures
-        if (fRadius2 < fRadius1) {
-            SkTSwap(fCenter1, fCenter2);
-            SkTSwap(fRadius1, fRadius2);
-            this->flipGradientColors();
-            fFlippedGrad = true;
-        } else {
-            fFlippedGrad = false;
-        }
-    }
     this->init();
 };
 
 void SkTwoPointConicalGradient::flatten(
     SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fCenter1);
     buffer.writePoint(fCenter2);
     buffer.writeScalar(fRadius1);
     buffer.writeScalar(fRadius2);
-    buffer.writeBool(fFlippedGrad);
 }
 
 #if SK_SUPPORT_GPU
 
 GrEffectRef* SkTwoPointConicalGradient::asNewEffect(GrContext* context, const SkPaint&) const {
     SkASSERT(NULL != context);
     SkASSERT(fPtsToUnit.isIdentity());
 
     return Gr2PtConicalGradientEffect::Create(context, *this, fTileMode);
 }
@@ skipping 25 matching lines @@
     str->appendScalar(fCenter2.fY);
     str->append(") radius2: ");
     str->appendScalar(fRadius2);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif