Style Change: NULL->nullptr

src/core/SkPathMeasure.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 "SkPathMeasure.h"
@@ skipping 279 matching lines @@
                 tangent->normalize();
             }
             break;
         case kConic_SegType: {
             SkConic(pts[0], pts[2], pts[3], pts[1].fX).evalAt(t, pos, tangent);
             if (tangent) {
                 tangent->normalize();
             }
         } break;
         case kCubic_SegType:
-            SkEvalCubicAt(pts, t, pos, tangent, NULL);
+            SkEvalCubicAt(pts, t, pos, tangent, nullptr);
             if (tangent) {
                 tangent->normalize();
             }
             break;
         default:
             SkDEBUGFAIL("unknown segType");
     }
 }
 
 static void seg_to(const SkPoint pts[], int segType,
@@ skipping 84 matching lines @@
         default:
             SkDEBUGFAIL("unknown segType");
             sk_throw();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPathMeasure::SkPathMeasure() {
-    fPath = NULL;
+    fPath = nullptr;
     fLength = -1;   // signal we need to compute it
     fForceClosed = false;
     fFirstPtIndex = -1;
 }
 
 SkPathMeasure::SkPathMeasure(const SkPath& path, bool forceClosed) {
     fPath = &path;
     fLength = -1;   // signal we need to compute it
     fForceClosed = forceClosed;
     fFirstPtIndex = -1;
@@ skipping 12 matching lines @@
     fFirstPtIndex = -1;
 
     if (path) {
         fIter.setPath(*path, forceClosed);
     }
     fSegments.reset();
     fPts.reset();
 }
 
 SkScalar SkPathMeasure::getLength() {
-    if (fPath == NULL) {
+    if (fPath == nullptr) {
         return 0;
     }
     if (fLength < 0) {
         this->buildSegments();
     }
     SkASSERT(fLength >= 0);
     return fLength;
 }
 
 template <typename T, typename K>
 int SkTKSearch(const T base[], int count, const K& key) {
     SkASSERT(count >= 0);
     if (count <= 0) {
         return ~0;
     }
     
-    SkASSERT(base != NULL); // base may be NULL if count is zero
+    SkASSERT(base != nullptr); // base may be nullptr if count is zero
     
     int lo = 0;
     int hi = count - 1;
     
     while (lo < hi) {
         int mid = (hi + lo) >> 1;
         if (base[mid].fDistance < key) {
             lo = mid + 1;
         } else {
             hi = mid;
@@ skipping 38 matching lines @@
     SkASSERT(seg->fDistance > startD);
 
     *t = startT + SkScalarMulDiv(seg->getScalarT() - startT,
                                  distance - startD,
                                  seg->fDistance - startD);
     return seg;
 }
 
 bool SkPathMeasure::getPosTan(SkScalar distance, SkPoint* pos,
                               SkVector* tangent) {
-    if (NULL == fPath) {
+    if (nullptr == fPath) {
         return false;
     }
 
     SkScalar    length = this->getLength(); // call this to force computing it
     int         count = fSegments.count();
 
     if (count == 0 || length == 0) {
         return false;
     }
 
     // pin the distance to a legal range
     if (distance < 0) {
         distance = 0;
     } else if (distance > length) {
         distance = length;
     }
 
     SkScalar        t;
     const Segment*  seg = this->distanceToSegment(distance, &t);
 
     compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, t, pos, tangent);
     return true;
 }
 
 bool SkPathMeasure::getMatrix(SkScalar distance, SkMatrix* matrix,
                               MatrixFlags flags) {
-    if (NULL == fPath) {
+    if (nullptr == fPath) {
         return false;
     }
 
     SkPoint     position;
     SkVector    tangent;
 
     if (this->getPosTan(distance, &position, &tangent)) {
         if (matrix) {
             if (flags & kGetTangent_MatrixFlag) {
                 matrix->setSinCos(tangent.fY, tangent.fX, 0, 0);
@@ skipping 25 matching lines @@
         return false;
     }
 
     SkPoint  p;
     SkScalar startT, stopT;
     const Segment* seg = this->distanceToSegment(startD, &startT);
     const Segment* stopSeg = this->distanceToSegment(stopD, &stopT);
     SkASSERT(seg <= stopSeg);
 
     if (startWithMoveTo) {
-        compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, startT, &p, NULL);
+        compute_pos_tan(&fPts[seg->fPtIndex], seg->fType, startT, &p, nullptr);
         dst->moveTo(p);
     }
 
     if (seg->fPtIndex == stopSeg->fPtIndex) {
         seg_to(&fPts[seg->fPtIndex], seg->fType, startT, stopT, dst);
     } else {
         do {
             seg_to(&fPts[seg->fPtIndex], seg->fType, startT, SK_Scalar1, dst);
             seg = SkPathMeasure::NextSegment(seg);
             startT = 0;
@@ skipping 26 matching lines @@
 
     for (int i = 0; i < fSegments.count(); i++) {
         const Segment* seg = &fSegments[i];
         SkDebugf("pathmeas: seg[%d] distance=%g, point=%d, t=%g, type=%d\n",
                 i, seg->fDistance, seg->fPtIndex, seg->getScalarT(),
                  seg->fType);
     }
 }
 
 #endif