Style Change: NULL->nullptr

src/utils/SkLayer.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 "SkLayer.h"
 #include "SkCanvas.h"
 
 //#define DEBUG_DRAW_LAYER_BOUNDS
 //#define DEBUG_TRACK_NEW_DELETE
 
 #ifdef DEBUG_TRACK_NEW_DELETE
     static int gLayerAllocCount;
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkLayer::SkLayer() {
-    fParent = NULL;
+    fParent = nullptr;
     m_opacity = SK_Scalar1;
     m_size.set(0, 0);
     m_position.set(0, 0);
     m_anchorPoint.set(SK_ScalarHalf, SK_ScalarHalf);
 
     fMatrix.reset();
     fChildrenMatrix.reset();
     fFlags = 0;
 
 #ifdef DEBUG_TRACK_NEW_DELETE
     gLayerAllocCount += 1;
     SkDebugf("SkLayer new:    %d\n", gLayerAllocCount);
 #endif
 }
 
 SkLayer::SkLayer(const SkLayer& src) : INHERITED() {
-    fParent = NULL;
+    fParent = nullptr;
     m_opacity = src.m_opacity;
     m_size = src.m_size;
     m_position = src.m_position;
     m_anchorPoint = src.m_anchorPoint;
 
     fMatrix = src.fMatrix;
     fChildrenMatrix = src.fChildrenMatrix;
     fFlags = src.fFlags;
 
 #ifdef DEBUG_TRACK_NEW_DELETE
@@ skipping 37 matching lines @@
 
 int SkLayer::countChildren() const {
     return m_children.count();
 }
 
 SkLayer* SkLayer::getChild(int index) const {
     if ((unsigned)index < (unsigned)m_children.count()) {
         SkASSERT(m_children[index]->fParent == this);
         return m_children[index];
     }
-    return NULL;
+    return nullptr;
 }
 
 SkLayer* SkLayer::addChild(SkLayer* child) {
     SkASSERT(this != child);
     child->ref();
     child->detachFromParent();
-    SkASSERT(child->fParent == NULL);
+    SkASSERT(child->fParent == nullptr);
     child->fParent = this;
 
     *m_children.append() = child;
     return child;
 }
 
 void SkLayer::detachFromParent() {
     if (fParent) {
         int index = fParent->m_children.find(this);
         SkASSERT(index >= 0);
         fParent->m_children.remove(index);
-        fParent = NULL;
+        fParent = nullptr;
         this->unref();  // this call might delete us
     }
 }
 
 void SkLayer::removeChildren() {
     int count = m_children.count();
     for (int i = 0; i < count; i++) {
         SkLayer* child = m_children[i];
         SkASSERT(child->fParent == this);
-        child->fParent = NULL;  // in case it has more than one owner
+        child->fParent = nullptr;  // in case it has more than one owner
         child->unref();
     }
     m_children.reset();
 }
 
 SkLayer* SkLayer::getRootLayer() const {
     const SkLayer* root = this;
-    while (root->fParent != NULL) {
+    while (root->fParent != nullptr) {
         root = root->fParent;
     }
     return const_cast<SkLayer*>(root);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkLayer::getLocalTransform(SkMatrix* matrix) const {
     matrix->setTranslate(m_position.fX, m_position.fY);
 
     SkScalar tx = SkScalarMul(m_anchorPoint.fX, m_size.width());
     SkScalar ty = SkScalarMul(m_anchorPoint.fY, m_size.height());
     matrix->preTranslate(tx, ty);
     matrix->preConcat(this->getMatrix());
     matrix->preTranslate(-tx, -ty);
 }
 
 void SkLayer::localToGlobal(SkMatrix* matrix) const {
     this->getLocalTransform(matrix);
 
     if (this->isInheritFromRootTransform()) {
         matrix->postConcat(this->getRootLayer()->getMatrix());
         return;
     }
 
     const SkLayer* layer = this;
-    while (layer->fParent != NULL) {
+    while (layer->fParent != nullptr) {
         layer = layer->fParent;
 
         SkMatrix tmp;
         layer->getLocalTransform(&tmp);
         tmp.preConcat(layer->getChildrenMatrix());
         matrix->postConcat(tmp);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 50 matching lines @@
 #endif
 
     int count = this->countChildren();
     if (count > 0) {
         canvas->concat(this->getChildrenMatrix());
         for (int i = 0; i < count; i++) {
             this->getChild(i)->draw(canvas, opacity);
         }
     }
 }