align top and bounds computations

src/pathops/SkDCubicLineIntersection.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 "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 
@@ skipping 117 matching lines @@
         SkDCubic::Coefficients(&c[0].fX, &A, &B, &C, &D);
         int count = SkDCubic::RootsValidT(A, B, C, D, roots);
         for (int index = 0; index < count; ++index) {
             SkDPoint calcPt = c.ptAtT(roots[index]);
             if (!approximately_zero(calcPt.fX)) {
                 for (int n = 0; n < 4; ++n) {
                     c[n].fY = (fCubic[n].fY - fLine[0].fY) * opp
                             + (fCubic[n].fX - fLine[0].fX) * adj;
                 }
                 double extremeTs[6];
-                int extrema = SkDCubic::FindExtrema(c[0].fX, c[1].fX, c[2].fX, c[3].fX, extremeTs);
+                int extrema = SkDCubic::FindExtrema(&c[0].fX, extremeTs);
                 count = c.searchRoots(extremeTs, extrema, 0, SkDCubic::kXAxis, roots);
                 break;
             }
         }
         return count;
     }
 
     int intersect() {
         addExactEndPoints();
         if (fAllowNear) {
@@ skipping 15 matching lines @@
 
     static int HorizontalIntersect(const SkDCubic& c, double axisIntercept, double roots[3]) {
         double A, B, C, D;
         SkDCubic::Coefficients(&c[0].fY, &A, &B, &C, &D);
         D -= axisIntercept;
         int count = SkDCubic::RootsValidT(A, B, C, D, roots);
         for (int index = 0; index < count; ++index) {
             SkDPoint calcPt = c.ptAtT(roots[index]);
             if (!approximately_equal(calcPt.fY, axisIntercept)) {
                 double extremeTs[6];
-                int extrema = SkDCubic::FindExtrema(c[0].fY, c[1].fY, c[2].fY, c[3].fY, extremeTs);
+                int extrema = SkDCubic::FindExtrema(&c[0].fY, extremeTs);
                 count = c.searchRoots(extremeTs, extrema, axisIntercept, SkDCubic::kYAxis, roots);
                 break;
             }
         }
         return count;
     }
 
     int horizontalIntersect(double axisIntercept, double left, double right, bool flipped) {
         addExactHorizontalEndPoints(left, right, axisIntercept);
         if (fAllowNear) {
@@ skipping 42 matching lines @@
 
     static int VerticalIntersect(const SkDCubic& c, double axisIntercept, double roots[3]) {
         double A, B, C, D;
         SkDCubic::Coefficients(&c[0].fX, &A, &B, &C, &D);
         D -= axisIntercept;
         int count = SkDCubic::RootsValidT(A, B, C, D, roots);
         for (int index = 0; index < count; ++index) {
             SkDPoint calcPt = c.ptAtT(roots[index]);
             if (!approximately_equal(calcPt.fX, axisIntercept)) {
                 double extremeTs[6];
-                int extrema = SkDCubic::FindExtrema(c[0].fX, c[1].fX, c[2].fX, c[3].fX, extremeTs);
+                int extrema = SkDCubic::FindExtrema(&c[0].fX, extremeTs);
                 count = c.searchRoots(extremeTs, extrema, axisIntercept, SkDCubic::kXAxis, roots);
                 break;
             }
         }
         return count;
     }
 
     int verticalIntersect(double axisIntercept, double top, double bottom, bool flipped) {
         addExactVerticalEndPoints(top, bottom, axisIntercept);
         if (fAllowNear) {
@@ skipping 170 matching lines @@
 }
 
 int SkIntersections::intersectRay(const SkDCubic& cubic, const SkDLine& line) {
     LineCubicIntersections c(cubic, line, this);
     fUsed = c.intersectRay(fT[0]);
     for (int index = 0; index < fUsed; ++index) {
         fPt[index] = cubic.ptAtT(fT[0][index]);
     }
     return fUsed;
 }