Style Change: NULL->nullptr

src/animator/SkDrawExtraPathEffect.cpp

 /*
  * Copyright 2006 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 "SkDrawExtraPathEffect.h"
 #include "SkDrawPath.h"
 #include "Sk1DPathEffect.h"
@@ skipping 72 matching lines @@
 #include "SkDrawMatrix.h"
 #include "SkPaint.h"
 
 class SkShape1DPathEffect : public Sk1DPathEffect {
 public:
     SkShape1DPathEffect(SkDrawShape1DPathEffect* draw, SkAnimateMaker* maker) :
         fDraw(draw), fMaker(maker) {
     }
 
     // For serialization.  This will never be called.
-    Factory getFactory() const override { sk_throw(); return NULL; }
+    Factory getFactory() const override { sk_throw(); return nullptr; }
 
 protected:
     SkScalar begin(SkScalar contourLength) const override {
         SkScriptValue value;
-        SkAnimatorScript engine(*fMaker, NULL, SkType_Float);
+        SkAnimatorScript engine(*fMaker, nullptr, SkType_Float);
         engine.propertyCallBack(GetContourLength, &contourLength);
         value.fOperand.fScalar = 0;
         engine.evaluate(fDraw->phase.c_str(), &value, SkType_Float);
         return value.fOperand.fScalar;
     }
 
     SkScalar next(SkPath* dst, SkScalar distance, SkPathMeasure&) const override {
         fMaker->setExtraPropertyCallBack(fDraw->fType, GetDistance, &distance);
-        SkDrawPath* drawPath = NULL;
+        SkDrawPath* drawPath = nullptr;
         if (fDraw->addPath->isPath()) {
             drawPath = (SkDrawPath*) fDraw->addPath;
         } else {
             SkApply* apply = (SkApply*) fDraw->addPath;
             apply->refresh(*fMaker);
             apply->activate(*fMaker);
             apply->interpolate(*fMaker, SkScalarRoundToInt(distance * 1000));
             drawPath = (SkDrawPath*) apply->getScope();
         }
         SkMatrix m;
         m.reset();
         if (fDraw->addMatrix) {
             SkDrawMatrix* matrix;
             if (fDraw->addMatrix->getType() == SkType_Matrix)
                 matrix = (SkDrawMatrix*) fDraw->addMatrix;
             else {
                 SkApply* apply = (SkApply*) fDraw->addMatrix;
                 apply->refresh(*fMaker);
                 apply->activate(*fMaker);
                 apply->interpolate(*fMaker, SkScalarRoundToInt(distance * 1000));
                 matrix = (SkDrawMatrix*) apply->getScope();
             }
             if (matrix) {
                 m = matrix->getMatrix();
             }
         }
         SkScalar result = 0;
-        SkAnimatorScript::EvaluateFloat(*fMaker, NULL, fDraw->spacing.c_str(), &result);
+        SkAnimatorScript::EvaluateFloat(*fMaker, nullptr, fDraw->spacing.c_str(), &result);
         if (drawPath)
             dst->addPath(drawPath->getPath(), m);
         fMaker->clearExtraPropertyCallBack(fDraw->fType);
         return result;
     }
 
 #ifndef SK_IGNORE_TO_STRING
     void toString(SkString* str) const override {
         str->appendf("SkShape1DPathEffect: (");
         // TODO: fill in
@@ skipping 32 matching lines @@
     SK_MEMBER(addMatrix, Drawable), // either matrix or apply
     SK_MEMBER(addPath, Drawable),   // either path or apply
     SK_MEMBER(path, Path),
 };
 
 #endif
 
 DEFINE_GET_MEMBER(SkDrawShapePathEffect);
 
 SkDrawShapePathEffect::SkDrawShapePathEffect() :
-    addPath(NULL), addMatrix(NULL), path(NULL), fPathEffect(NULL) {
+    addPath(nullptr), addMatrix(nullptr), path(nullptr), fPathEffect(nullptr) {
 }
 
 SkDrawShapePathEffect::~SkDrawShapePathEffect() {
     SkSafeUnref(fPathEffect);
 }
 
 bool SkDrawShapePathEffect::addChild(SkAnimateMaker& , SkDisplayable* child) {
     path = (SkDrawPath*) child;
     return true;
 }
@@ skipping 17 matching lines @@
 
 DEFINE_GET_MEMBER(SkDrawShape1DPathEffect);
 
 SkDrawShape1DPathEffect::SkDrawShape1DPathEffect(SkDisplayTypes type) : fType(type) {
 }
 
 SkDrawShape1DPathEffect::~SkDrawShape1DPathEffect() {
 }
 
 void SkDrawShape1DPathEffect::onEndElement(SkAnimateMaker& maker) {
-    if (addPath == NULL || (addPath->isPath() == false && addPath->isApply() == false))
+    if (addPath == nullptr || (addPath->isPath() == false && addPath->isApply() == false))
         maker.setErrorCode(SkDisplayXMLParserError::kUnknownError); // !!! add error
     else
         fPathEffect = new SkShape1DPathEffect(this, &maker);
 }
 
 ////////// SkShape2DPathEffect
 
 class SkShape2DPathEffect : public Sk2DPathEffect {
 public:
     SkShape2DPathEffect(SkDrawShape2DPathEffect* draw, SkAnimateMaker* maker,
         const SkMatrix& matrix) : Sk2DPathEffect(matrix), fDraw(draw), fMaker(maker) {
     }
 
     // For serialization.  This will never be called.
-    Factory getFactory() const override { sk_throw(); return NULL; }
+    Factory getFactory() const override { sk_throw(); return nullptr; }
 
 protected:
     void begin(const SkIRect& uvBounds, SkPath*) const override {
         const_cast<SkShape2DPathEffect*>(this)->setUVBounds(uvBounds);
     }
 
     void next(const SkPoint& loc, int u, int v, SkPath* dst) const override {
         const_cast<SkShape2DPathEffect*>(this)->addPath(loc, u, v, dst);
     }
 
@@ skipping 11 matching lines @@
         fMaker->setExtraPropertyCallBack(fDraw->fType, Get2D, this);
         if (fDraw->addPath->isPath()) {
             drawPath = (SkDrawPath*) fDraw->addPath;
         } else {
             SkApply* apply = (SkApply*) fDraw->addPath;
             apply->refresh(*fMaker);
             apply->activate(*fMaker);
             apply->interpolate(*fMaker, v);
             drawPath = (SkDrawPath*) apply->getScope();
         }
-        if (drawPath == NULL)
+        if (drawPath == nullptr)
             goto clearCallBack;
         if (fDraw->matrix) {
             SkDrawMatrix* matrix;
             if (fDraw->matrix->getType() == SkType_Matrix)
                 matrix = (SkDrawMatrix*) fDraw->matrix;
             else {
                 SkApply* apply = (SkApply*) fDraw->matrix;
                 apply->activate(*fMaker);
                 apply->interpolate(*fMaker, v);
                 matrix = (SkDrawMatrix*) apply->getScope();
@@ skipping 50 matching lines @@
 
 DEFINE_GET_MEMBER(SkDrawShape2DPathEffect);
 
 SkDrawShape2DPathEffect::SkDrawShape2DPathEffect(SkDisplayTypes type) : fType(type) {
 }
 
 SkDrawShape2DPathEffect::~SkDrawShape2DPathEffect() {
 }
 
 void SkDrawShape2DPathEffect::onEndElement(SkAnimateMaker& maker) {
-    if (addPath == NULL || (addPath->isPath() == false && addPath->isApply() == false) ||
-            matrix == NULL)
+    if (addPath == nullptr || (addPath->isPath() == false && addPath->isApply() == false) ||
+            matrix == nullptr)
         maker.setErrorCode(SkDisplayXMLParserError::kUnknownError); // !!! add error
     else
         fPathEffect = new SkShape2DPathEffect(this, &maker, matrix->getMatrix());
 }
 
 ////////// SkDrawComposePathEffect
 
 #if SK_USE_CONDENSED_INFO == 0
 
 const SkMemberInfo SkDrawComposePathEffect::fInfo[] = {
     SK_MEMBER(effect1, PathEffect),
     SK_MEMBER(effect2, PathEffect)
 };
 
 #endif
 
 DEFINE_GET_MEMBER(SkDrawComposePathEffect);
 
 SkDrawComposePathEffect::SkDrawComposePathEffect(SkDisplayTypes type) : fType(type),
-    effect1(NULL), effect2(NULL) {
+    effect1(nullptr), effect2(nullptr) {
 }
 
 SkDrawComposePathEffect::~SkDrawComposePathEffect() {
     delete effect1;
     delete effect2;
 }
 
 bool SkDrawComposePathEffect::addChild(SkAnimateMaker& , SkDisplayable* child) {
-    if (effect1 == NULL)
+    if (effect1 == nullptr)
         effect1 = (SkDrawPathEffect*) child;
     else
         effect2 = (SkDrawPathEffect*) child;
     return true;
 }
 
 SkPathEffect* SkDrawComposePathEffect::getPathEffect() {
     SkPathEffect* e1 = effect1->getPathEffect();
     SkPathEffect* e2 = effect2->getPathEffect();
     SkPathEffect* composite = SkComposePathEffect::Create(e1, e2);
@@ skipping 41 matching lines @@
 class SkExtraPathEffects : public SkExtras {
 public:
     SkExtraPathEffects() :
             skDrawShape1DPathEffectType(SkType_Unknown),
             skDrawShape2DPathEffectType(SkType_Unknown),
             skDrawComposePathEffectType(SkType_Unknown),
             skDrawCornerPathEffectType(SkType_Unknown) {
     }
 
     virtual SkDisplayable* createInstance(SkDisplayTypes type) {
-        SkDisplayable* result = NULL;
+        SkDisplayable* result = nullptr;
         if (skDrawShape1DPathEffectType == type)
             result = new SkDrawShape1DPathEffect(type);
         else if (skDrawShape2DPathEffectType == type)
             result = new SkDrawShape2DPathEffect(type);
         else if (skDrawComposePathEffectType == type)
             result = new SkDrawComposePathEffect(type);
         else if (skDrawCornerPathEffectType == type)
             result = new SkDrawCornerPathEffect(type);
         return result;
     }
 
     virtual bool definesType(SkDisplayTypes type) {
         return type == skDrawShape1DPathEffectType ||
             type == skDrawShape2DPathEffectType ||
             type == skDrawComposePathEffectType ||
             type == skDrawCornerPathEffectType;
     }
 
 #if SK_USE_CONDENSED_INFO == 0
     virtual const SkMemberInfo* getMembers(SkDisplayTypes type, int* infoCountPtr) {
-        const SkMemberInfo* info = NULL;
+        const SkMemberInfo* info = nullptr;
         int infoCount = 0;
         if (skDrawShape1DPathEffectType == type) {
             info = SkDrawShape1DPathEffect::fInfo;
             infoCount = SkDrawShape1DPathEffect::fInfoCount;
         } else if (skDrawShape2DPathEffectType == type) {
             info = SkDrawShape2DPathEffect::fInfo;
             infoCount = SkDrawShape2DPathEffect::fInfoCount;
         } else if (skDrawComposePathEffectType == type) {
             info = SkDrawComposePathEffect::fInfo;
             infoCount = SkDrawShape1DPathEffect::fInfoCount;
@@ skipping 10 matching lines @@
 #ifdef SK_DEBUG
     virtual const char* getName(SkDisplayTypes type) {
         if (skDrawShape1DPathEffectType == type)
             return kDrawShape1DPathEffectName;
         else if (skDrawShape2DPathEffectType == type)
             return kDrawShape2DPathEffectName;
         else if (skDrawComposePathEffectType == type)
             return kDrawComposePathEffectName;
         else if (skDrawCornerPathEffectType == type)
             return kDrawCornerPathEffectName;
-        return NULL;
+        return nullptr;
     }
 #endif
 
     virtual SkDisplayTypes getType(const char name[], size_t len ) {
-        SkDisplayTypes* type = NULL;
+        SkDisplayTypes* type = nullptr;
         if (SK_LITERAL_STR_EQUAL(kDrawShape1DPathEffectName, name, len))
             type = &skDrawShape1DPathEffectType;
         else if (SK_LITERAL_STR_EQUAL(kDrawShape2DPathEffectName, name, len))
             type = &skDrawShape2DPathEffectType;
         else if (SK_LITERAL_STR_EQUAL(kDrawComposePathEffectName, name, len))
             type = &skDrawComposePathEffectType;
         else if (SK_LITERAL_STR_EQUAL(kDrawCornerPathEffectName, name, len))
             type = &skDrawCornerPathEffectType;
         if (type) {
             if (*type == SkType_Unknown)
@@ skipping 10 matching lines @@
     SkDisplayTypes skDrawCornerPathEffectType;
 };
 
 void InitializeSkExtraPathEffects(SkAnimator* animator) {
     animator->addExtras(new SkExtraPathEffects());
 }
 
 ////////////////
 
 
-SkExtras::SkExtras() : fExtraCallBack(NULL), fExtraStorage(NULL) {
+SkExtras::SkExtras() : fExtraCallBack(nullptr), fExtraStorage(nullptr) {
 }