turn off debugging printfs

src/pathops/SkPathOpsQuad.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 "SkLineParameters.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsQuad.h"
@@ skipping 12 matching lines @@
     double b = 3 * A.dot(B);
     double c = 2 * A.dot(A) + pos.dot(B);
     double d = pos.dot(A);
     double ts[3];
     int roots = SkDCubic::RootsValidT(a, b, c, d, ts);
     double d0 = pt.distanceSquared(fPts[0]);
     double d2 = pt.distanceSquared(fPts[2]);
     double distMin = SkTMin(d0, d2);
     int bestIndex = -1;
     for (int index = 0; index < roots; ++index) {
-        SkDPoint onQuad = xyAtT(ts[index]);
+        SkDPoint onQuad = ptAtT(ts[index]);
         double dist = pt.distanceSquared(onQuad);
         if (distMin > dist) {
             distMin = dist;
             bestIndex = index;
         }
     }
     if (bestIndex >= 0) {
         return ts[bestIndex];
     }
     return d0 < d2 ? 0 : 1;
 }
 
 bool SkDQuad::pointInHull(const SkDPoint& pt) const {
     return ((const SkDTriangle&) fPts).contains(pt);
 }
 
 SkDPoint SkDQuad::top(double startT, double endT) const {
     SkDQuad sub = subDivide(startT, endT);
     SkDPoint topPt = sub[0];
     if (topPt.fY > sub[2].fY || (topPt.fY == sub[2].fY && topPt.fX > sub[2].fX)) {
         topPt = sub[2];
     }
     if (!between(sub[0].fY, sub[1].fY, sub[2].fY)) {
         double extremeT;
         if (FindExtrema(sub[0].fY, sub[1].fY, sub[2].fY, &extremeT)) {
             extremeT = startT + (endT - startT) * extremeT;
-            SkDPoint test = xyAtT(extremeT);
+            SkDPoint test = ptAtT(extremeT);
             if (topPt.fY > test.fY || (topPt.fY == test.fY && topPt.fX > test.fX)) {
                 topPt = test;
             }
         }
     }
     return topPt;
 }
 
 int SkDQuad::AddValidTs(double s[], int realRoots, double* t) {
     int foundRoots = 0;
@@ skipping 87 matching lines @@
 SkDVector SkDQuad::dxdyAtT(double t) const {
     double a = t - 1;
     double b = 1 - 2 * t;
     double c = t;
     SkDVector result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
             a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
     return result;
 }
 
 // OPTIMIZE: assert if caller passes in t == 0 / t == 1 ?
-SkDPoint SkDQuad::xyAtT(double t) const {
+SkDPoint SkDQuad::ptAtT(double t) const {
+    if (0 == t) {
+        return fPts[0];
+    }
+    if (1 == t) {
+        return fPts[2];
+    }
     double one_t = 1 - t;
     double a = one_t * one_t;
     double b = 2 * one_t * t;
     double c = t * t;
     SkDPoint result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
             a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
     return result;
 }
 
 /*
@@ skipping 148 matching lines @@
  * c =             C
  */
 void SkDQuad::SetABC(const double* quad, double* a, double* b, double* c) {
     *a = quad[0];      // a = A
     *b = 2 * quad[2];  // b =     2*B
     *c = quad[4];      // c =             C
     *b -= *c;          // b =     2*B -   C
     *a -= *b;          // a = A - 2*B +   C
     *b -= *c;          // b =     2*B - 2*C
 }