Style Change: NULL->nullptr

src/gpu/GrTessellatingPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 107 matching lines @@
     if (t->*Prev) {
         t->*Prev->*Next = t->*Next;
     } else if (head) {
         *head = t->*Next;
     }
     if (t->*Next) {
         t->*Next->*Prev = t->*Prev;
     } else if (tail) {
         *tail = t->*Prev;
     }
-    t->*Prev = t->*Next = NULL;
+    t->*Prev = t->*Next = nullptr;
 }
 
 /**
  * Vertices are used in three ways: first, the path contours are converted into a
  * circularly-linked list of Vertices for each contour. After edge construction, the same Vertices
  * are re-ordered by the merge sort according to the sweep_lt comparator (usually, increasing
  * in Y) using the same fPrev/fNext pointers that were used for the contours, to avoid
  * reallocation. Finally, MonotonePolys are built containing a circularly-linked list of
  * Vertices. (Currently, those Vertices are newly-allocated for the MonotonePolys, since
  * an individual Vertex from the path mesh may belong to multiple
  * MonotonePolys, so the original Vertices cannot be re-used.
  */
 
 struct Vertex {
   Vertex(const SkPoint& point)
-    : fPoint(point), fPrev(NULL), fNext(NULL)
-    , fFirstEdgeAbove(NULL), fLastEdgeAbove(NULL)
-    , fFirstEdgeBelow(NULL), fLastEdgeBelow(NULL)
+    : fPoint(point), fPrev(nullptr), fNext(nullptr)
+    , fFirstEdgeAbove(nullptr), fLastEdgeAbove(nullptr)
+    , fFirstEdgeBelow(nullptr), fLastEdgeBelow(nullptr)
     , fProcessed(false)
 #if LOGGING_ENABLED
     , fID (-1.0f)
 #endif
     {}
     SkPoint fPoint;           // Vertex position
     Vertex* fPrev;            // Linked list of contours, then Y-sorted vertices.
     Vertex* fNext;            // "
     Edge*   fFirstEdgeAbove;  // Linked list of edges above this vertex.
     Edge*   fLastEdgeAbove;   // "
@@ skipping 45 matching lines @@
     data = emit_vertex(v0, data);
 #else
     data = emit_vertex(v0, data);
     data = emit_vertex(v1, data);
     data = emit_vertex(v2, data);
 #endif
     return data;
 }
 
 struct EdgeList {
-    EdgeList() : fHead(NULL), fTail(NULL) {}
+    EdgeList() : fHead(nullptr), fTail(nullptr) {}
     Edge* fHead;
     Edge* fTail;
 };
 
 /**
  * An Edge joins a top Vertex to a bottom Vertex. Edge ordering for the list of "edges above" and
  * "edge below" a vertex as well as for the active edge list is handled by isLeftOf()/isRightOf().
  * Note that an Edge will give occasionally dist() != 0 for its own endpoints (because floating
  * point). For speed, that case is only tested by the callers which require it (e.g.,
  * cleanup_active_edges()). Edges also handle checking for intersection with other edges.
  * Currently, this converts the edges to the parametric form, in order to avoid doing a division
  * until an intersection has been confirmed. This is slightly slower in the "found" case, but
  * a lot faster in the "not found" case.
  *
  * The coefficients of the line equation stored in double precision to avoid catastrphic
  * cancellation in the isLeftOf() and isRightOf() checks. Using doubles ensures that the result is
  * correct in float, since it's a polynomial of degree 2. The intersect() function, being
  * degree 5, is still subject to catastrophic cancellation. We deal with that by assuming its
  * output may be incorrect, and adjusting the mesh topology to match (see comment at the top of
  * this file).
  */
 
 struct Edge {
     Edge(Vertex* top, Vertex* bottom, int winding)
         : fWinding(winding)
         , fTop(top)
         , fBottom(bottom)
-        , fLeft(NULL)
-        , fRight(NULL)
-        , fPrevEdgeAbove(NULL)
-        , fNextEdgeAbove(NULL)
-        , fPrevEdgeBelow(NULL)
-        , fNextEdgeBelow(NULL)
-        , fLeftPoly(NULL)
-        , fRightPoly(NULL) {
+        , fLeft(nullptr)
+        , fRight(nullptr)
+        , fPrevEdgeAbove(nullptr)
+        , fNextEdgeAbove(nullptr)
+        , fPrevEdgeBelow(nullptr)
+        , fNextEdgeBelow(nullptr)
+        , fLeftPoly(nullptr)
+        , fRightPoly(nullptr) {
             recompute();
         }
     int      fWinding;          // 1 == edge goes downward; -1 = edge goes upward.
     Vertex*  fTop;              // The top vertex in vertex-sort-order (sweep_lt).
     Vertex*  fBottom;           // The bottom vertex in vertex-sort-order.
     Edge*    fLeft;             // The linked list of edges in the active edge list.
     Edge*    fRight;            // "
     Edge*    fPrevEdgeAbove;    // The linked list of edges in the bottom Vertex's "edges above".
     Edge*    fNextEdgeAbove;    // "
     Edge*    fPrevEdgeBelow;    // The linked list of edges in the top Vertex's "edges below".
@@ skipping 48 matching lines @@
     bool isActive(EdgeList* activeEdges) const {
         return activeEdges && (fLeft || fRight || activeEdges->fHead == this);
     }
 };
 
 /***************************************************************************************/
 
 struct Poly {
     Poly(int winding)
         : fWinding(winding)
-        , fHead(NULL)
-        , fTail(NULL)
-        , fActive(NULL)
-        , fNext(NULL)
-        , fPartner(NULL)
+        , fHead(nullptr)
+        , fTail(nullptr)
+        , fActive(nullptr)
+        , fNext(nullptr)
+        , fPartner(nullptr)
         , fCount(0)
     {
 #if LOGGING_ENABLED
         static int gID = 0;
         fID = gID++;
         LOG("*** created Poly %d\n", fID);
 #endif
     }
     typedef enum { kNeither_Side, kLeft_Side, kRight_Side } Side;
     struct MonotonePoly {
         MonotonePoly()
             : fSide(kNeither_Side)
-            , fHead(NULL)
-            , fTail(NULL)
-            , fPrev(NULL)
-            , fNext(NULL) {}
+            , fHead(nullptr)
+            , fTail(nullptr)
+            , fPrev(nullptr)
+            , fNext(nullptr) {}
         Side          fSide;
         Vertex*       fHead;
         Vertex*       fTail;
         MonotonePoly* fPrev;
         MonotonePoly* fNext;
         bool addVertex(Vertex* v, Side side, SkChunkAlloc& alloc) {
             Vertex* newV = ALLOC_NEW(Vertex, (v->fPoint), alloc);
             bool done = false;
             if (fSide == kNeither_Side) {
                 fSide = side;
             } else {
                 done = side != fSide;
             }
-            if (fHead == NULL) {
+            if (fHead == nullptr) {
                 fHead = fTail = newV;
             } else if (fSide == kRight_Side) {
                 newV->fPrev = fTail;
                 fTail->fNext = newV;
                 fTail = newV;
             } else {
                 newV->fNext = fHead;
                 fHead->fPrev = newV;
                 fHead = newV;
             }
@@ skipping 27 matching lines @@
             }
             return data;
         }
     };
     Poly* addVertex(Vertex* v, Side side, SkChunkAlloc& alloc) {
         LOG("addVertex() to %d at %g (%g, %g), %s side\n", fID, v->fID, v->fPoint.fX, v->fPoint.fY,
                side == kLeft_Side ? "left" : side == kRight_Side ? "right" : "neither");
         Poly* partner = fPartner;
         Poly* poly = this;
         if (partner) {
-            fPartner = partner->fPartner = NULL;
+            fPartner = partner->fPartner = nullptr;
         }
         if (!fActive) {
             fActive = ALLOC_NEW(MonotonePoly, (), alloc);
         }
         if (fActive->addVertex(v, side, alloc)) {
             if (fTail) {
                 fActive->fPrev = fTail;
                 fTail->fNext = fActive;
                 fTail = fActive;
             } else {
                 fHead = fTail = fActive;
             }
             if (partner) {
                 partner->addVertex(v, side, alloc);
                 poly = partner;
             } else {
                 Vertex* prev = fActive->fSide == Poly::kLeft_Side ?
                                fActive->fHead->fNext : fActive->fTail->fPrev;
                 fActive = ALLOC_NEW(MonotonePoly, , alloc);
                 fActive->addVertex(prev, Poly::kNeither_Side, alloc);
                 fActive->addVertex(v, side, alloc);
             }
         }
         fCount++;
         return poly;
     }
     void end(Vertex* v, SkChunkAlloc& alloc) {
         LOG("end() %d at %g, %g\n", fID, v->fPoint.fX, v->fPoint.fY);
         if (fPartner) {
-            fPartner = fPartner->fPartner = NULL;
+            fPartner = fPartner->fPartner = nullptr;
         }
         addVertex(v, fActive->fSide == kLeft_Side ? kRight_Side : kLeft_Side, alloc);
     }
     SkPoint* emit(SkPoint *data) {
         if (fCount < 3) {
             return data;
         }
         LOG("emit() %d, size %d\n", fID, fCount);
-        for (MonotonePoly* m = fHead; m != NULL; m = m->fNext) {
+        for (MonotonePoly* m = fHead; m != nullptr; m = m->fNext) {
             data = m->emit(data);
         }
         return data;
     }
     int fWinding;
     MonotonePoly* fHead;
     MonotonePoly* fTail;
     MonotonePoly* fActive;
     Poly* fNext;
     Poly* fPartner;
@@ skipping 93 matching lines @@
 
 void path_to_contours(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
                       Vertex** contours, SkChunkAlloc& alloc, bool *isLinear) {
 
     SkScalar toleranceSqd = tolerance * tolerance;
 
     SkPoint pts[4];
     bool done = false;
     *isLinear = true;
     SkPath::Iter iter(path, false);
-    Vertex* prev = NULL;
-    Vertex* head = NULL;
+    Vertex* prev = nullptr;
+    Vertex* head = nullptr;
     if (path.isInverseFillType()) {
         SkPoint quad[4];
         clipBounds.toQuad(quad);
         for (int i = 3; i >= 0; i--) {
             prev = append_point_to_contour(quad[i], prev, &head, alloc);
         }
         head->fPrev = prev;
         prev->fNext = head;
         *contours++ = head;
-        head = prev = NULL;
+        head = prev = nullptr;
     }
     SkAutoConicToQuads converter;
     while (!done) {
         SkPath::Verb verb = iter.next(pts);
         switch (verb) {
             case SkPath::kConic_Verb: {
                 SkScalar weight = iter.conicWeight();
                 const SkPoint* quadPts = converter.computeQuads(pts, weight, toleranceSqd);
                 for (int i = 0; i < converter.countQuads(); ++i) {
                     int pointsLeft = GrPathUtils::quadraticPointCount(quadPts, tolerance);
                     prev = generate_quadratic_points(quadPts[0], quadPts[1], quadPts[2],
                                                      toleranceSqd, prev, &head, pointsLeft, alloc);
                     quadPts += 2;
                 }
                 *isLinear = false;
                 break;
             }
             case SkPath::kMove_Verb:
                 if (head) {
                     head->fPrev = prev;
                     prev->fNext = head;
                     *contours++ = head;
                 }
-                head = prev = NULL;
+                head = prev = nullptr;
                 prev = append_point_to_contour(pts[0], prev, &head, alloc);
                 break;
             case SkPath::kLine_Verb: {
                 prev = append_point_to_contour(pts[1], prev, &head, alloc);
                 break;
             }
             case SkPath::kQuad_Verb: {
                 int pointsLeft = GrPathUtils::quadraticPointCount(pts, tolerance);
                 prev = generate_quadratic_points(pts[0], pts[1], pts[2], toleranceSqd, prev,
                                                  &head, pointsLeft, alloc);
                 *isLinear = false;
                 break;
             }
             case SkPath::kCubic_Verb: {
                 int pointsLeft = GrPathUtils::cubicPointCount(pts, tolerance);
                 prev = generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
                                 toleranceSqd, prev, &head, pointsLeft, alloc);
                 *isLinear = false;
                 break;
             }
             case SkPath::kClose_Verb:
                 if (head) {
                     head->fPrev = prev;
                     prev->fNext = head;
                     *contours++ = head;
                 }
-                head = prev = NULL;
+                head = prev = nullptr;
                 break;
             case SkPath::kDone_Verb:
                 if (head) {
                     head->fPrev = prev;
                     prev->fNext = head;
                     *contours++ = head;
                 }
                 done = true;
                 break;
         }
@@ skipping 35 matching lines @@
     Edge* next = prev ? prev->fRight : edges->fHead;
     insert<Edge, &Edge::fLeft, &Edge::fRight>(edge, prev, next, &edges->fHead, &edges->fTail);
 }
 
 void find_enclosing_edges(Vertex* v, EdgeList* edges, Edge** left, Edge** right) {
     if (v->fFirstEdgeAbove) {
         *left = v->fFirstEdgeAbove->fLeft;
         *right = v->fLastEdgeAbove->fRight;
         return;
     }
-    Edge* next = NULL;
+    Edge* next = nullptr;
     Edge* prev;
-    for (prev = edges->fTail; prev != NULL; prev = prev->fLeft) {
+    for (prev = edges->fTail; prev != nullptr; prev = prev->fLeft) {
         if (prev->isLeftOf(v)) {
             break;
         }
         next = prev;
     }
     *left = prev;
     *right = next;
     return;
 }
 
 void find_enclosing_edges(Edge* edge, EdgeList* edges, Comparator& c, Edge** left, Edge** right) {
-    Edge* prev = NULL;
+    Edge* prev = nullptr;
     Edge* next;
-    for (next = edges->fHead; next != NULL; next = next->fRight) {
+    for (next = edges->fHead; next != nullptr; next = next->fRight) {
         if ((c.sweep_gt(edge->fTop->fPoint, next->fTop->fPoint) && next->isRightOf(edge->fTop)) ||
             (c.sweep_gt(next->fTop->fPoint, edge->fTop->fPoint) && edge->isLeftOf(next->fTop)) ||
             (c.sweep_lt(edge->fBottom->fPoint, next->fBottom->fPoint) &&
              next->isRightOf(edge->fBottom)) ||
             (c.sweep_lt(next->fBottom->fPoint, edge->fBottom->fPoint) &&
              edge->isLeftOf(next->fBottom))) {
             break;
         }
         prev = next;
     }
@@ skipping 14 matching lines @@
         insert_edge(edge, left, activeEdges);
     }
 }
 
 void insert_edge_above(Edge* edge, Vertex* v, Comparator& c) {
     if (edge->fTop->fPoint == edge->fBottom->fPoint ||
         c.sweep_gt(edge->fTop->fPoint, edge->fBottom->fPoint)) {
         return;
     }
     LOG("insert edge (%g -> %g) above vertex %g\n", edge->fTop->fID, edge->fBottom->fID, v->fID);
-    Edge* prev = NULL;
+    Edge* prev = nullptr;
     Edge* next;
     for (next = v->fFirstEdgeAbove; next; next = next->fNextEdgeAbove) {
         if (next->isRightOf(edge->fTop)) {
             break;
         }
         prev = next;
     }
     insert<Edge, &Edge::fPrevEdgeAbove, &Edge::fNextEdgeAbove>(
         edge, prev, next, &v->fFirstEdgeAbove, &v->fLastEdgeAbove);
 }
 
 void insert_edge_below(Edge* edge, Vertex* v, Comparator& c) {
     if (edge->fTop->fPoint == edge->fBottom->fPoint ||
         c.sweep_gt(edge->fTop->fPoint, edge->fBottom->fPoint)) {
         return;
     }
     LOG("insert edge (%g -> %g) below vertex %g\n", edge->fTop->fID, edge->fBottom->fID, v->fID);
-    Edge* prev = NULL;
+    Edge* prev = nullptr;
     Edge* next;
     for (next = v->fFirstEdgeBelow; next; next = next->fNextEdgeBelow) {
         if (next->isRightOf(edge->fBottom)) {
             break;
         }
         prev = next;
     }
     insert<Edge, &Edge::fPrevEdgeBelow, &Edge::fNextEdgeBelow>(
         edge, prev, next, &v->fFirstEdgeBelow, &v->fLastEdgeBelow);
 }
@@ skipping 154 matching lines @@
         fix_active_state(newEdge, activeEdges, c);
         merge_collinear_edges(newEdge, activeEdges, c);
     }
 }
 
 void merge_vertices(Vertex* src, Vertex* dst, Vertex** head, Comparator& c, SkChunkAlloc& alloc) {
     LOG("found coincident verts at %g, %g; merging %g into %g\n", src->fPoint.fX, src->fPoint.fY,
         src->fID, dst->fID);
     for (Edge* edge = src->fFirstEdgeAbove; edge;) {
         Edge* next = edge->fNextEdgeAbove;
-        set_bottom(edge, dst, NULL, c);
+        set_bottom(edge, dst, nullptr, c);
         edge = next;
     }
     for (Edge* edge = src->fFirstEdgeBelow; edge;) {
         Edge* next = edge->fNextEdgeBelow;
-        set_top(edge, dst, NULL, c);
+        set_top(edge, dst, nullptr, c);
         edge = next;
     }
-    remove<Vertex, &Vertex::fPrev, &Vertex::fNext>(src, head, NULL);
+    remove<Vertex, &Vertex::fPrev, &Vertex::fNext>(src, head, nullptr);
 }
 
 Vertex* check_for_intersection(Edge* edge, Edge* other, EdgeList* activeEdges, Comparator& c,
                                SkChunkAlloc& alloc) {
     SkPoint p;
     if (!edge || !other) {
-        return NULL;
+        return nullptr;
     }
     if (edge->intersect(*other, &p)) {
         Vertex* v;
         LOG("found intersection, pt is %g, %g\n", p.fX, p.fY);
         if (p == edge->fTop->fPoint || c.sweep_lt(p, edge->fTop->fPoint)) {
             split_edge(other, edge->fTop, activeEdges, c, alloc);
             v = edge->fTop;
         } else if (p == edge->fBottom->fPoint || c.sweep_gt(p, edge->fBottom->fPoint)) {
             split_edge(other, edge->fBottom, activeEdges, c, alloc);
             v = edge->fBottom;
@@ skipping 27 matching lines @@
                 v->fPrev = prevV;
                 v->fNext = nextV;
                 prevV->fNext = v;
                 nextV->fPrev = v;
             }
             split_edge(edge, v, activeEdges, c, alloc);
             split_edge(other, v, activeEdges, c, alloc);
         }
         return v;
     }
-    return NULL;
+    return nullptr;
 }
 
 void sanitize_contours(Vertex** contours, int contourCnt) {
     for (int i = 0; i < contourCnt; ++i) {
         SkASSERT(contours[i]);
         for (Vertex* v = contours[i];;) {
             if (coincident(v->fPrev->fPoint, v->fPoint)) {
                 LOG("vertex %g,%g coincident; removing\n", v->fPoint.fX, v->fPoint.fY);
                 if (v->fPrev == v) {
-                    contours[i] = NULL;
+                    contours[i] = nullptr;
                     break;
                 }
                 v->fPrev->fNext = v->fNext;
                 v->fNext->fPrev = v->fPrev;
                 if (contours[i] == v) {
                     contours[i] = v->fNext;
                 }
                 v = v->fPrev;
             } else {
                 v = v->fNext;
                 if (v == contours[i]) break;
             }
         }
     }
 }
 
 void merge_coincident_vertices(Vertex** vertices, Comparator& c, SkChunkAlloc& alloc) {
-    for (Vertex* v = (*vertices)->fNext; v != NULL; v = v->fNext) {
+    for (Vertex* v = (*vertices)->fNext; v != nullptr; v = v->fNext) {
         if (c.sweep_lt(v->fPoint, v->fPrev->fPoint)) {
             v->fPoint = v->fPrev->fPoint;
         }
         if (coincident(v->fPrev->fPoint, v->fPoint)) {
             merge_vertices(v->fPrev, v, vertices, c, alloc);
         }
     }
 }
 
 // Stage 2: convert the contours to a mesh of edges connecting the vertices.
 
 Vertex* build_edges(Vertex** contours, int contourCnt, Comparator& c, SkChunkAlloc& alloc) {
-    Vertex* vertices = NULL;
-    Vertex* prev = NULL;
+    Vertex* vertices = nullptr;
+    Vertex* prev = nullptr;
     for (int i = 0; i < contourCnt; ++i) {
-        for (Vertex* v = contours[i]; v != NULL;) {
+        for (Vertex* v = contours[i]; v != nullptr;) {
             Vertex* vNext = v->fNext;
             Edge* edge = new_edge(v->fPrev, v, alloc, c);
             if (edge->fWinding > 0) {
                 insert_edge_below(edge, v->fPrev, c);
                 insert_edge_above(edge, v, c);
             } else {
                 insert_edge_below(edge, v, c);
                 insert_edge_above(edge, v->fPrev, c);
             }
-            merge_collinear_edges(edge, NULL, c);
+            merge_collinear_edges(edge, nullptr, c);
             if (prev) {
                 prev->fNext = v;
                 v->fPrev = prev;
             } else {
                 vertices = v;
             }
             prev = v;
             v = vNext;
             if (v == contours[i]) break;
         }
     }
     if (prev) {
-        prev->fNext = vertices->fPrev = NULL;
+        prev->fNext = vertices->fPrev = nullptr;
     }
     return vertices;
 }
 
 // Stage 3: sort the vertices by increasing sweep direction.
 
 Vertex* sorted_merge(Vertex* a, Vertex* b, Comparator& c);
 
 void front_back_split(Vertex* v, Vertex** pFront, Vertex** pBack) {
     Vertex* fast;
     Vertex* slow;
     if (!v || !v->fNext) {
         *pFront = v;
-        *pBack = NULL;
+        *pBack = nullptr;
     } else {
         slow = v;
         fast = v->fNext;
 
-        while (fast != NULL) {
+        while (fast != nullptr) {
             fast = fast->fNext;
-            if (fast != NULL) {
+            if (fast != nullptr) {
                 slow = slow->fNext;
                 fast = fast->fNext;
             }
         }
 
         *pFront = v;
         *pBack = slow->fNext;
-        slow->fNext->fPrev = NULL;
-        slow->fNext = NULL;
+        slow->fNext->fPrev = nullptr;
+        slow->fNext = nullptr;
     }
 }
 
 void merge_sort(Vertex** head, Comparator& c) {
     if (!*head || !(*head)->fNext) {
         return;
     }
 
     Vertex* a;
     Vertex* b;
     front_back_split(*head, &a, &b);
 
     merge_sort(&a, c);
     merge_sort(&b, c);
 
     *head = sorted_merge(a, b, c);
 }
 
 inline void append_vertex(Vertex* v, Vertex** head, Vertex** tail) {
-    insert<Vertex, &Vertex::fPrev, &Vertex::fNext>(v, *tail, NULL, head, tail);
+    insert<Vertex, &Vertex::fPrev, &Vertex::fNext>(v, *tail, nullptr, head, tail);
 }
 
 inline void append_vertex_list(Vertex* v, Vertex** head, Vertex** tail) {
     insert<Vertex, &Vertex::fPrev, &Vertex::fNext>(v, *tail, v->fNext, head, tail);
 }
 
 Vertex* sorted_merge(Vertex* a, Vertex* b, Comparator& c) {
-    Vertex* head = NULL;
-    Vertex* tail = NULL;
+    Vertex* head = nullptr;
+    Vertex* tail = nullptr;
 
     while (a && b) {
         if (c.sweep_lt(a->fPoint, b->fPoint)) {
             Vertex* next = a->fNext;
             append_vertex(a, &head, &tail);
             a = next;
         } else {
             Vertex* next = b->fNext;
             append_vertex(b, &head, &tail);
             b = next;
         }
     }
     if (a) {
         append_vertex_list(a, &head, &tail);
     }
     if (b) {
         append_vertex_list(b, &head, &tail);
     }
     return head;
 }
 
 // Stage 4: Simplify the mesh by inserting new vertices at intersecting edges.
 
 void simplify(Vertex* vertices, Comparator& c, SkChunkAlloc& alloc) {
     LOG("simplifying complex polygons\n");
     EdgeList activeEdges;
-    for (Vertex* v = vertices; v != NULL; v = v->fNext) {
+    for (Vertex* v = vertices; v != nullptr; v = v->fNext) {
         if (!v->fFirstEdgeAbove && !v->fFirstEdgeBelow) {
             continue;
         }
 #if LOGGING_ENABLED
         LOG("\nvertex %g: (%g,%g)\n", v->fID, v->fPoint.fX, v->fPoint.fY);
 #endif
-        Edge* leftEnclosingEdge = NULL;
-        Edge* rightEnclosingEdge = NULL;
+        Edge* leftEnclosingEdge = nullptr;
+        Edge* rightEnclosingEdge = nullptr;
         bool restartChecks;
         do {
             restartChecks = false;
             find_enclosing_edges(v, &activeEdges, &leftEnclosingEdge, &rightEnclosingEdge);
             if (v->fFirstEdgeBelow) {
-                for (Edge* edge = v->fFirstEdgeBelow; edge != NULL; edge = edge->fNextEdgeBelow) {
+                for (Edge* edge = v->fFirstEdgeBelow; edge != nullptr; edge = edge->fNextEdgeBelow) {
                     if (check_for_intersection(edge, leftEnclosingEdge, &activeEdges, c, alloc)) {
                         restartChecks = true;
                         break;
                     }
                     if (check_for_intersection(edge, rightEnclosingEdge, &activeEdges, c, alloc)) {
                         restartChecks = true;
                         break;
                     }
                 }
             } else {
@@ skipping 17 matching lines @@
         }
         v->fProcessed = true;
     }
 }
 
 // Stage 5: Tessellate the simplified mesh into monotone polygons.
 
 Poly* tessellate(Vertex* vertices, SkChunkAlloc& alloc) {
     LOG("tessellating simple polygons\n");
     EdgeList activeEdges;
-    Poly* polys = NULL;
-    for (Vertex* v = vertices; v != NULL; v = v->fNext) {
+    Poly* polys = nullptr;
+    for (Vertex* v = vertices; v != nullptr; v = v->fNext) {
         if (!v->fFirstEdgeAbove && !v->fFirstEdgeBelow) {
             continue;
         }
 #if LOGGING_ENABLED
         LOG("\nvertex %g: (%g,%g)\n", v->fID, v->fPoint.fX, v->fPoint.fY);
 #endif
-        Edge* leftEnclosingEdge = NULL;
-        Edge* rightEnclosingEdge = NULL;
+        Edge* leftEnclosingEdge = nullptr;
+        Edge* rightEnclosingEdge = nullptr;
         find_enclosing_edges(v, &activeEdges, &leftEnclosingEdge, &rightEnclosingEdge);
-        Poly* leftPoly = NULL;
-        Poly* rightPoly = NULL;
+        Poly* leftPoly = nullptr;
+        Poly* rightPoly = nullptr;
         if (v->fFirstEdgeAbove) {
             leftPoly = v->fFirstEdgeAbove->fLeftPoly;
             rightPoly = v->fLastEdgeAbove->fRightPoly;
         } else {
-            leftPoly = leftEnclosingEdge ? leftEnclosingEdge->fRightPoly : NULL;
-            rightPoly = rightEnclosingEdge ? rightEnclosingEdge->fLeftPoly : NULL;
+            leftPoly = leftEnclosingEdge ? leftEnclosingEdge->fRightPoly : nullptr;
+            rightPoly = rightEnclosingEdge ? rightEnclosingEdge->fLeftPoly : nullptr;
         }
 #if LOGGING_ENABLED
         LOG("edges above:\n");
         for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) {
             LOG("%g -> %g, lpoly %d, rpoly %d\n", e->fTop->fID, e->fBottom->fID,
                 e->fLeftPoly ? e->fLeftPoly->fID : -1, e->fRightPoly ? e->fRightPoly->fID : -1);
         }
         LOG("edges below:\n");
         for (Edge* e = v->fFirstEdgeBelow; e; e = e->fNextEdgeBelow) {
             LOG("%g -> %g, lpoly %d, rpoly %d\n", e->fTop->fID, e->fBottom->fID,
@@ skipping 15 matching lines @@
                 if (leftEdge->fRightPoly) {
                     leftEdge->fRightPoly->end(v, alloc);
                 }
                 if (rightEdge->fLeftPoly && rightEdge->fLeftPoly != leftEdge->fRightPoly) {
                     rightEdge->fLeftPoly->end(v, alloc);
                 }
             }
             remove_edge(v->fLastEdgeAbove, &activeEdges);
             if (!v->fFirstEdgeBelow) {
                 if (leftPoly && rightPoly && leftPoly != rightPoly) {
-                    SkASSERT(leftPoly->fPartner == NULL && rightPoly->fPartner == NULL);
+                    SkASSERT(leftPoly->fPartner == nullptr && rightPoly->fPartner == nullptr);
                     rightPoly->fPartner = leftPoly;
                     leftPoly->fPartner = rightPoly;
                 }
             }
         }
         if (v->fFirstEdgeBelow) {
             if (!v->fFirstEdgeAbove) {
                 if (leftPoly && leftPoly == rightPoly) {
                     // Split the poly.
                     if (leftPoly->fActive->fSide == Poly::kLeft_Side) {
@@ skipping 29 matching lines @@
                 if (winding != 0) {
                     Poly* poly = new_poly(&polys, v, winding, alloc);
                     leftEdge->fRightPoly = rightEdge->fLeftPoly = poly;
                 }
                 leftEdge = rightEdge;
             }
             v->fLastEdgeBelow->fRightPoly = rightPoly;
         }
 #if LOGGING_ENABLED
         LOG("\nactive edges:\n");
-        for (Edge* e = activeEdges.fHead; e != NULL; e = e->fRight) {
+        for (Edge* e = activeEdges.fHead; e != nullptr; e = e->fRight) {
             LOG("%g -> %g, lpoly %d, rpoly %d\n", e->fTop->fID, e->fBottom->fID,
                 e->fLeftPoly ? e->fLeftPoly->fID : -1, e->fRightPoly ? e->fRightPoly->fID : -1);
         }
 #endif
     }
     return polys;
 }
 
 // This is a driver function which calls stages 2-5 in turn.
 
 Poly* contours_to_polys(Vertex** contours, int contourCnt, Comparator& c, SkChunkAlloc& alloc) {
 #if LOGGING_ENABLED
     for (int i = 0; i < contourCnt; ++i) {
         Vertex* v = contours[i];
         SkASSERT(v);
         LOG("path.moveTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
         for (v = v->fNext; v != contours[i]; v = v->fNext) {
             LOG("path.lineTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
         }
     }
 #endif
     sanitize_contours(contours, contourCnt);
     Vertex* vertices = build_edges(contours, contourCnt, c, alloc);
     if (!vertices) {
-        return NULL;
+        return nullptr;
     }
 
     // Sort vertices in Y (secondarily in X).
     merge_sort(&vertices, c);
     merge_coincident_vertices(&vertices, c, alloc);
 #if LOGGING_ENABLED
-    for (Vertex* v = vertices; v != NULL; v = v->fNext) {
+    for (Vertex* v = vertices; v != nullptr; v = v->fNext) {
         static float gID = 0.0f;
         v->fID = gID++;
     }
 #endif
     simplify(vertices, c, alloc);
     return tessellate(vertices, alloc);
 }
 
 // Stage 6: Triangulate the monotone polygons into a vertex buffer.
 
@@ skipping 44 matching lines @@
         SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
     }
 };
 
 }  // namespace
 
 bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // This path renderer can draw all fill styles, all stroke styles except hairlines, but does
     // not do antialiasing. It can do convex and concave paths, but we'll leave the convex ones to
     // simpler algorithms.
-    return !IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, NULL) &&
+    return !IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, nullptr) &&
            !args.fAntiAlias && !args.fPath->isConvex();
 }
 
 class TessellatingPathBatch : public GrVertexBatch {
 public:
 
     static GrDrawBatch* Create(const GrColor& color,
                                const SkPath& path,
                                const GrStrokeInfo& stroke,
                                const SkMatrix& viewMatrix,
@@ skipping 219 matching lines @@
     SkPath                  fPath;
     GrStrokeInfo            fStroke;
     SkMatrix                fViewMatrix;
     SkRect                  fClipBounds; // in source space
     GrPipelineOptimizations fPipelineInfo;
 };
 
 bool GrTessellatingPathRenderer::onDrawPath(const DrawPathArgs& args) {
     SkASSERT(!args.fAntiAlias);
     const GrRenderTarget* rt = args.fPipelineBuilder->getRenderTarget();
-    if (NULL == rt) {
+    if (nullptr == rt) {
         return false;
     }
 
     SkIRect clipBoundsI;
     args.fPipelineBuilder->clip().getConservativeBounds(rt, &clipBoundsI);
     SkRect clipBounds = SkRect::Make(clipBoundsI);
     SkMatrix vmi;
     if (!args.fViewMatrix->invert(&vmi)) {
         return false;
     }
@@ skipping 19 matching lines @@
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif