Style Change: NULL->nullptr

src/core/SkClipStack.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAtomics.h"
 #include "SkCanvas.h"
 #include "SkClipStack.h"
@@ skipping 377 matching lines @@
 
     // First, optimistically update the current Element's bound information
     // with the current clip's bound
     fIsIntersectionOfRects = false;
     switch (fType) {
         case kRect_Type:
             fFiniteBound = this->getRect();
             fFiniteBoundType = kNormal_BoundsType;
 
             if (SkRegion::kReplace_Op == fOp ||
-                (SkRegion::kIntersect_Op == fOp && NULL == prior) ||
+                (SkRegion::kIntersect_Op == fOp && nullptr == prior) ||
                 (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
                     prior->rectRectIntersectAllowed(this->getRect(), fDoAA))) {
                 fIsIntersectionOfRects = true;
             }
             break;
         case kRRect_Type:
             fFiniteBound = fRRect.getBounds();
             fFiniteBoundType = kNormal_BoundsType;
             break;
         case kPath_Type:
@@ skipping 15 matching lines @@
                          SkScalarRoundToScalar(fFiniteBound.fTop),
                          SkScalarRoundToScalar(fFiniteBound.fRight),
                          SkScalarRoundToScalar(fFiniteBound.fBottom));
     }
 
     // Now determine the previous Element's bound information taking into
     // account that there may be no previous clip
     SkRect prevFinite;
     SkClipStack::BoundsType prevType;
 
-    if (NULL == prior) {
+    if (nullptr == prior) {
         // no prior clip means the entire plane is writable
         prevFinite.setEmpty();   // there are no pixels that cannot be drawn to
         prevType = kInsideOut_BoundsType;
     } else {
         prevFinite = prior->fFiniteBound;
         prevType = prior->fFiniteBoundType;
     }
 
     FillCombo combination = kPrev_Cur_FillCombo;
     if (kInsideOut_BoundsType == fFiniteBoundType) {
@@ skipping 77 matching lines @@
 
 SkClipStack& SkClipStack::operator=(const SkClipStack& b) {
     if (this == &b) {
         return *this;
     }
     reset();
 
     fSaveCount = b.fSaveCount;
     SkDeque::F2BIter recIter(b.fDeque);
     for (const Element* element = (const Element*)recIter.next();
-         element != NULL;
+         element != nullptr;
          element = (const Element*)recIter.next()) {
         new (fDeque.push_back()) Element(*element);
     }
 
     return *this;
 }
 
 bool SkClipStack::operator==(const SkClipStack& b) const {
     if (this->getTopmostGenID() == b.getTopmostGenID()) {
         return true;
     }
     if (fSaveCount != b.fSaveCount ||
         fDeque.count() != b.fDeque.count()) {
         return false;
     }
     SkDeque::F2BIter myIter(fDeque);
     SkDeque::F2BIter bIter(b.fDeque);
     const Element* myElement = (const Element*)myIter.next();
     const Element* bElement = (const Element*)bIter.next();
 
-    while (myElement != NULL && bElement != NULL) {
+    while (myElement != nullptr && bElement != nullptr) {
         if (*myElement != *bElement) {
             return false;
         }
         myElement = (const Element*)myIter.next();
         bElement = (const Element*)bIter.next();
     }
-    return myElement == NULL && bElement == NULL;
+    return myElement == nullptr && bElement == nullptr;
 }
 
 void SkClipStack::reset() {
     // We used a placement new for each object in fDeque, so we're responsible
     // for calling the destructor on each of them as well.
     while (!fDeque.empty()) {
         Element* element = (Element*)fDeque.back();
         element->~Element();
         fDeque.pop_back();
     }
@@ skipping 21 matching lines @@
     }
 }
 
 void SkClipStack::getBounds(SkRect* canvFiniteBound,
                             BoundsType* boundType,
                             bool* isIntersectionOfRects) const {
     SkASSERT(canvFiniteBound && boundType);
 
     Element* element = (Element*)fDeque.back();
 
-    if (NULL == element) {
+    if (nullptr == element) {
         // the clip is wide open - the infinite plane w/ no pixels un-writeable
         canvFiniteBound->setEmpty();
         *boundType = kInsideOut_BoundsType;
         if (isIntersectionOfRects) {
             *isIntersectionOfRects = false;
         }
         return;
     }
 
     *canvFiniteBound = element->fFiniteBound;
     *boundType = element->fFiniteBoundType;
     if (isIntersectionOfRects) {
         *isIntersectionOfRects = element->fIsIntersectionOfRects;
     }
 }
 
 bool SkClipStack::quickContains(const SkRect& rect) const {
 
     Iter iter(*this, Iter::kTop_IterStart);
     const Element* element = iter.prev();
-    while (element != NULL) {
+    while (element != nullptr) {
         if (SkRegion::kIntersect_Op != element->getOp() && SkRegion::kReplace_Op != element->getOp())
             return false;
         if (element->isInverseFilled()) {
             // Part of 'rect' could be trimmed off by the inverse-filled clip element
             if (SkRect::Intersects(element->getBounds(), rect)) {
                 return false;
             }
         } else {
             if (!element->contains(rect)) {
                 return false;
@@ skipping 106 matching lines @@
 
     ((Element*)fDeque.back())->fGenID = kEmptyGenID;
 }
 
 bool SkClipStack::isWideOpen() const {
     return this->getTopmostGenID() == kWideOpenGenID;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkClipStack::Iter::Iter() : fStack(NULL) {
+SkClipStack::Iter::Iter() : fStack(nullptr) {
 }
 
 SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
     : fStack(&stack) {
     this->reset(stack, startLoc);
 }
 
 const SkClipStack::Element* SkClipStack::Iter::next() {
     return (const SkClipStack::Element*)fIter.next();
 }
 
 const SkClipStack::Element* SkClipStack::Iter::prev() {
     return (const SkClipStack::Element*)fIter.prev();
 }
 
 const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkRegion::Op op) {
 
-    if (NULL == fStack) {
-        return NULL;
+    if (nullptr == fStack) {
+        return nullptr;
     }
 
     fIter.reset(fStack->fDeque, SkDeque::Iter::kBack_IterStart);
 
-    const SkClipStack::Element* element = NULL;
+    const SkClipStack::Element* element = nullptr;
 
     for (element = (const SkClipStack::Element*) fIter.prev();
          element;
          element = (const SkClipStack::Element*) fIter.prev()) {
 
         if (op == element->fOp) {
             // The Deque's iterator is actually one pace ahead of the
             // returned value. So while "element" is the element we want to
             // return, the iterator is actually pointing at (and will
             // return on the next "next" or "prev" call) the element
             // in front of it in the deque. Bump the iterator forward a
             // step so we get the expected result.
-            if (NULL == fIter.next()) {
+            if (nullptr == fIter.next()) {
                 // The reverse iterator has run off the front of the deque
                 // (i.e., the "op" clip is the first clip) and can't
                 // recover. Reset the iterator to start at the front.
                 fIter.reset(fStack->fDeque, SkDeque::Iter::kFront_IterStart);
             }
             break;
         }
     }
 
-    if (NULL == element) {
+    if (nullptr == element) {
         // There were no "op" clips
         fIter.reset(fStack->fDeque, SkDeque::Iter::kFront_IterStart);
     }
 
     return this->next();
 }
 
 void SkClipStack::Iter::reset(const SkClipStack& stack, IterStart startLoc) {
     fStack = &stack;
     fIter.reset(stack.fDeque, static_cast<SkDeque::Iter::IterStart>(startLoc));
@@ skipping 84 matching lines @@
             break;
         case kRect_Type:
             this->getRect().dump();
             SkDebugf("\n");
             break;
         case kRRect_Type:
             this->getRRect().dump();
             SkDebugf("\n");
             break;
         case kPath_Type:
-            this->getPath().dump(NULL, true, false);
+            this->getPath().dump(nullptr, true, false);
             break;
     }
 }
 
 void SkClipStack::dump() const {
     B2TIter iter(*this);
     const Element* e;
     while ((e = iter.next())) {
         e->dump();
         SkDebugf("\n");
     }
 }
 #endif