remove unused fields from SkOpSegment

src/pathops/SkPathOpsCubic.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 "SkGeometry.h"
 #include "SkLineParameters.h"
 #include "SkPathOpsConic.h"
 #include "SkPathOpsCubic.h"
@@ skipping 211 matching lines @@
             fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY), fPts[3].fX), fPts[3].fY);
     largest = SkTMax(largest, -tiniest);
     double distance = lineParameters.controlPtDistance(*this, 1);
     if (!approximately_zero_when_compared_to(distance, largest)) {
         return false;
     }
     distance = lineParameters.controlPtDistance(*this, 2);
     return approximately_zero_when_compared_to(distance, largest);
 }
 
-bool SkDCubic::ComplexBreak(const SkPoint pointsPtr[4], SkScalar* t, CubicType* resultType) {
+bool SkDCubic::ComplexBreak(const SkPoint pointsPtr[4], SkScalar* t) {
     SkScalar d[3];
     SkCubicType cubicType = SkClassifyCubic(pointsPtr, d);
     if (cubicType == kLoop_SkCubicType) {
         // crib code from gpu path utils that finds t values where loop self-intersects
         // use it to find mid of t values which should be a friendly place to chop
         SkScalar tempSqrt = SkScalarSqrt(4.f * d[0] * d[2] - 3.f * d[1] * d[1]);
         SkScalar ls = d[1] - tempSqrt;
         SkScalar lt = 2.f * d[0];
         SkScalar ms = d[1] + tempSqrt;
         SkScalar mt = 2.f * d[0];
         if (between(0, ls, lt) || between(0, ms, mt)) {
             ls = ls / lt;
             ms = ms / mt;
             SkScalar smaller = SkTMax(0.f, SkTMin(ls, ms));
             SkScalar larger = SkTMin(1.f, SkTMax(ls, ms));
             *t = (smaller + larger) / 2;
-            *resultType = kSplitAtLoop_SkDCubicType;
             return *t > 0 && *t < 1;
         }
     } else if (kSerpentine_SkCubicType == cubicType || kCusp_SkCubicType == cubicType) {
         SkDCubic cubic;
         cubic.set(pointsPtr);
         double inflectionTs[2];
         int infTCount = cubic.findInflections(inflectionTs);
         if (infTCount == 2) {
             double maxCurvature[3];
             int roots = cubic.findMaxCurvature(maxCurvature);
@@ skipping 11 matching lines @@
                 SkDebugf("maxCurvature[%d]=%1.9g ", index, maxCurvature[index]);
                 SkDPoint pt = cubic.ptAtT(maxCurvature[index]);
                 SkDVector dPt = cubic.dxdyAtT(maxCurvature[index]);
                 SkDLine perp = {{pt - dPt, pt + dPt}};
                 perp.dump();
             }
 #endif
             for (int index = 0; index < roots; ++index) {
                 if (between(inflectionTs[0], maxCurvature[index], inflectionTs[1])) {
                     *t = maxCurvature[index];
-                    *resultType = kSplitAtMaxCurvature_SkDCubicType;
                     return true;
                 }
             }
         } else if (infTCount == 1) {
             *t = inflectionTs[0];
-            *resultType = kSplitAtInflection_SkDCubicType;
             return *t > 0 && *t < 1;
         }
     }
     return false;
 }
 
 bool SkDCubic::monotonicInX() const {
     return precisely_between(fPts[0].fX, fPts[1].fX, fPts[3].fX)
             && precisely_between(fPts[0].fX, fPts[2].fX, fPts[3].fX);
 }
@@ skipping 394 matching lines @@
     for (int index = 0; index < roots; ++index) {
         double t = startT + (endT - startT) * extremeTs[index];
         SkDPoint mid = dCurve.ptAtT(t);
         if (topPt->fY > mid.fY || (topPt->fY == mid.fY && topPt->fX > mid.fX)) {
             topT = t;
             *topPt = mid;
         }
     }
     return topT;
 }