Style Change: NULL->nullptr

src/core/SkStroke.cpp

 /*
  * Copyright 2008 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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
@@ skipping 278 matching lines @@
             fOuter.close();
             // now add fInner as its own contour
             fInner.getLastPt(&pt);
             fOuter.moveTo(pt.fX, pt.fY);
             fOuter.reversePathTo(fInner);
             fOuter.close();
         } else {    // add caps to start and end
             // cap the end
             fInner.getLastPt(&pt);
             fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
-                    currIsLine ? &fInner : NULL);
+                    currIsLine ? &fInner : nullptr);
             fOuter.reversePathTo(fInner);
             // cap the start
             fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
-                    fPrevIsLine ? &fInner : NULL);
+                    fPrevIsLine ? &fInner : nullptr);
             fOuter.close();
         }
     }
     // since we may re-use fInner, we rewind instead of reset, to save on
     // reallocating its internal storage.
     fInner.rewind();
     fSegmentCount = -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 232 matching lines @@
         *tangentPtPtr = degenerateAB ? &cubic[2] : &cubic[1];
         return kQuad_ReductionType;
     }
     SkScalar tValues[3];
     int count = SkFindCubicMaxCurvature(cubic, tValues);
     if (count == 0) {
         return kLine_ReductionType;
     }
     for (int index = 0; index < count; ++index) {
         SkScalar t = tValues[index];
-        SkEvalCubicAt(cubic, t, &reduction[index], NULL, NULL);
+        SkEvalCubicAt(cubic, t, &reduction[index], nullptr, nullptr);
     }
     static_assert(kQuad_ReductionType + 1 == kDegenerate_ReductionType, "enum_out_of_whack");
     static_assert(kQuad_ReductionType + 2 == kDegenerate2_ReductionType, "enum_out_of_whack");
     static_assert(kQuad_ReductionType + 3 == kDegenerate3_ReductionType, "enum_out_of_whack");
 
     return (ReductionType) (kQuad_ReductionType + count);
 }
 
 SkPathStroker::ReductionType SkPathStroker::CheckConicLinear(const SkConic& conic,
         SkPoint* reduction) {
@@ skipping 15 matching lines @@
     }
 #else  // but for now, use extrema instead
     SkScalar xT = 0, yT = 0;
     (void) conic.findXExtrema(&xT);
     (void) conic.findYExtrema(&yT);
     SkScalar t = SkTMax(xT, yT); 
     if (0 == t) {
         return kLine_ReductionType;
     }
 #endif
-    conic.evalAt(t, reduction, NULL);
+    conic.evalAt(t, reduction, nullptr);
     return kDegenerate_ReductionType;
 }
 
 SkPathStroker::ReductionType SkPathStroker::CheckQuadLinear(const SkPoint quad[3],
         SkPoint* reduction) {
     bool degenerateAB = degenerate_vector(quad[1] - quad[0]);
     bool degenerateBC = degenerate_vector(quad[2] - quad[1]);
     if (degenerateAB & degenerateBC) {
         return kPoint_ReductionType;
     }
@@ skipping 128 matching lines @@
         quadPts->fEndSet = true;
     }
 }
 
 
 // Given a cubic and t, return the point on curve, its perpendicular, and the perpendicular tangent.
 // Returns false if the perpendicular could not be computed (because the derivative collapsed to 0)
 bool SkPathStroker::cubicPerpRay(const SkPoint cubic[4], SkScalar t, SkPoint* tPt, SkPoint* onPt,
         SkPoint* tangent) const {
     SkVector dxy;
-    SkEvalCubicAt(cubic, t, tPt, &dxy, NULL);
+    SkEvalCubicAt(cubic, t, tPt, &dxy, nullptr);
     if (dxy.fX == 0 && dxy.fY == 0) {
         if (SkScalarNearlyZero(t)) {
             dxy = cubic[2] - cubic[0];
         } else if (SkScalarNearlyZero(1 - t)) {
             dxy = cubic[3] - cubic[1];
         } else {
             return false;
         }
         if (dxy.fX == 0 && dxy.fY == 0) {
             dxy = cubic[3] - cubic[0];
@@ skipping 20 matching lines @@
             return false;
         }
         quadPts->fEndSet = true;
     }
     return true;
 }
 
 bool SkPathStroker::cubicQuadMid(const SkPoint cubic[4], const SkQuadConstruct* quadPts,
         SkPoint* mid) const {
     SkPoint cubicMidPt;
-    return this->cubicPerpRay(cubic, quadPts->fMidT, &cubicMidPt, mid, NULL);
+    return this->cubicPerpRay(cubic, quadPts->fMidT, &cubicMidPt, mid, nullptr);
 }
 
 // Given a quad and t, return the point on curve, its perpendicular, and the perpendicular tangent.
 void SkPathStroker::quadPerpRay(const SkPoint quad[3], SkScalar t, SkPoint* tPt, SkPoint* onPt,
         SkPoint* tangent) const {
     SkVector dxy;
     SkEvalQuadAt(quad, t, tPt, &dxy);
     if (dxy.fX == 0 && dxy.fY == 0) {
         dxy = quad[2] - quad[0];
     }
@@ skipping 176 matching lines @@
     if (!this->cubicQuadEnds(cubic, quadPts)) {
         return kNormalError_ResultType;
     }
     ResultType resultType = this->intersectRay(quadPts, kCtrlPt_RayType
             STROKER_DEBUG_PARAMS(fRecursionDepth) );
     if (resultType != kQuad_ResultType) {
         return resultType;
     }
     // project a ray from the curve to the stroke
     SkPoint ray[2];  // points near midpoint on quad, midpoint on cubic
-    if (!this->cubicPerpRay(cubic, quadPts->fMidT, &ray[1], &ray[0], NULL)) {
+    if (!this->cubicPerpRay(cubic, quadPts->fMidT, &ray[1], &ray[0], nullptr)) {
         return kNormalError_ResultType;
     }
     return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
             STROKER_DEBUG_PARAMS(fRecursionDepth));
 }
 
 SkPathStroker::ResultType SkPathStroker::compareQuadConic(const SkConic& conic,
         SkQuadConstruct* quadPts) const {
     // get the quadratic approximation of the stroke
     this->conicQuadEnds(conic, quadPts);
     ResultType resultType = this->intersectRay(quadPts, kCtrlPt_RayType
             STROKER_DEBUG_PARAMS(fRecursionDepth) );
     if (resultType != kQuad_ResultType) {
         return resultType;
     }
     // project a ray from the curve to the stroke
     SkPoint ray[2];  // points near midpoint on quad, midpoint on conic
-    this->conicPerpRay(conic, quadPts->fMidT, &ray[1], &ray[0], NULL);
+    this->conicPerpRay(conic, quadPts->fMidT, &ray[1], &ray[0], nullptr);
     return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
             STROKER_DEBUG_PARAMS(fRecursionDepth));
 }
 
 SkPathStroker::ResultType SkPathStroker::compareQuadQuad(const SkPoint quad[3],
         SkQuadConstruct* quadPts) {
     // get the quadratic approximation of the stroke
     if (!quadPts->fStartSet) {
         SkPoint quadStartPt;
         this->quadPerpRay(quad, quadPts->fStartT, &quadStartPt, &quadPts->fQuad[0],
                 &quadPts->fTangentStart);
         quadPts->fStartSet = true;
     }
     if (!quadPts->fEndSet) {
         SkPoint quadEndPt;
         this->quadPerpRay(quad, quadPts->fEndT, &quadEndPt, &quadPts->fQuad[2],
                 &quadPts->fTangentEnd);
         quadPts->fEndSet = true;
     }
     ResultType resultType = this->intersectRay(quadPts, kCtrlPt_RayType
             STROKER_DEBUG_PARAMS(fRecursionDepth));
     if (resultType != kQuad_ResultType) {
         return resultType;
     }
     // project a ray from the curve to the stroke
     SkPoint ray[2];
-    this->quadPerpRay(quad, quadPts->fMidT, &ray[1], &ray[0], NULL);
+    this->quadPerpRay(quad, quadPts->fMidT, &ray[1], &ray[0], nullptr);
     return this->strokeCloseEnough(quadPts->fQuad, ray, quadPts
             STROKER_DEBUG_PARAMS(fRecursionDepth));
 }
 
 void SkPathStroker::addDegenerateLine(const SkQuadConstruct* quadPts) {
     const SkPoint* quad = quadPts->fQuad;
     SkPath* path = fStrokeType == kOuter_StrokeType ? &fOuter : &fInner;
     path->lineTo(quad[2].fX, quad[2].fY);
 }
 
@@ skipping 387 matching lines @@
         pts[3].set(r.fRight, outer.fBottom);
         pts[2].set(r.fLeft, outer.fBottom);
         pts[1].set(outer.fLeft, r.fBottom);
         pts[0].set(outer.fLeft, r.fTop);
     }
     path->addPoly(pts, 8, true);
 }
 
 void SkStroke::strokeRect(const SkRect& origRect, SkPath* dst,
                           SkPath::Direction dir) const {
-    SkASSERT(dst != NULL);
+    SkASSERT(dst != nullptr);
     dst->reset();
 
     SkScalar radius = SkScalarHalf(fWidth);
     if (radius <= 0) {
         return;
     }
 
     SkScalar rw = origRect.width();
     SkScalar rh = origRect.height();
     if ((rw < 0) ^ (rh < 0)) {
@@ skipping 26 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }