Style Change: NULL->nullptr

src/animator/SkDisplayable.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 "SkDisplayable.h"
@@ skipping 46 matching lines @@
 }
 
 void SkDisplayable::clearBounder() {
 }
 
 bool SkDisplayable::contains(SkDisplayable* ) {
     return false;
 }
 
 SkDisplayable* SkDisplayable::contains(const SkString& ) {
-    return NULL;
+    return nullptr;
 }
 
 SkDisplayable* SkDisplayable::deepCopy(SkAnimateMaker* maker) {
     SkDisplayTypes type = getType();
     if (type == SkType_Unknown) {
         SkASSERT(0);
-        return NULL;
+        return nullptr;
     }
     SkDisplayable* copy = SkDisplayType::CreateInstance(maker, type);
     int index = -1;
     int propIndex = 0;
     const SkMemberInfo* info;
     do {
         info = copy->getMember(++index);
-        if (info == NULL)
+        if (info == nullptr)
             break;
         if (info->fType == SkType_MemberProperty) {
             SkScriptValue value;
             if (getProperty(propIndex, &value))
                 copy->setProperty(propIndex, value);
             propIndex++;
             continue;
         }
         if (info->fType == SkType_MemberFunction)
             continue;
         if (info->fType == SkType_Array) {
             SkTDOperandArray* array = (SkTDOperandArray*) info->memberData(this);
             int arrayCount;
-            if (array == NULL || (arrayCount = array->count()) == 0)
+            if (array == nullptr || (arrayCount = array->count()) == 0)
                 continue;
             SkTDOperandArray* copyArray = (SkTDOperandArray*) info->memberData(copy);
             copyArray->setCount(arrayCount);
             SkDisplayTypes elementType;
             if (type == SkType_Array) {
                 SkDisplayArray* dispArray = (SkDisplayArray*) this;
                 elementType = dispArray->values.getType();
             } else
                 elementType = info->arrayType();
             size_t elementSize = SkMemberInfo::GetSize(elementType);
             size_t byteSize = elementSize * arrayCount;
             memcpy(copyArray->begin(), array->begin(), byteSize);
             continue;
         }
         if (SkDisplayType::IsDisplayable(maker, info->fType)) {
             SkDisplayable** displayable = (SkDisplayable**) info->memberData(this);
-            if (*displayable == NULL || *displayable == (SkDisplayable*) -1)
+            if (*displayable == nullptr || *displayable == (SkDisplayable*) -1)
                 continue;
             SkDisplayable* deeper = (*displayable)->deepCopy(maker);
             info->setMemberData(copy, deeper, sizeof(deeper));
             continue;
         }
         if (info->fType == SkType_String || info->fType == SkType_DynamicString) {
             SkString* string;
             info->getString(this, &string);
             info->setString(copy, string);
             continue;
@@ skipping 29 matching lines @@
     int index = -1;
     int propIndex = 0;
     const SkMemberInfo* info;
     const SkMemberInfo* blankInfo;
     SkScriptValue value;
     SkScriptValue blankValue;
     SkOperand values[2];
     SkOperand blankValues[2];
     do {
         info = this->getMember(++index);
-        if (NULL == info) {
+        if (nullptr == info) {
             //SkDebugf("\n");
             break;
         }
         if (SkType_MemberProperty == info->fType) {
             if (getProperty(propIndex, &value)) {
                 blankCopy->getProperty(propIndex, &blankValue);
                 //last two are dummies
                 dumpValues(info, value.fType, value.fOperand, blankValue.fOperand, value.fOperand, blankValue.fOperand);
                 }
 
             propIndex++;
             continue;
         }
         if (SkDisplayType::IsDisplayable(maker, info->fType)) {
             continue;
         }
 
         if (info->fType == SkType_MemberFunction)
             continue;
 
 
         if (info->fType == SkType_Array) {
             SkTDOperandArray* array = (SkTDOperandArray*) info->memberData(this);
             int arrayCount;
-            if (array == NULL || (arrayCount = array->count()) == 0)
+            if (array == nullptr || (arrayCount = array->count()) == 0)
                 continue;
             SkDisplayTypes elementType;
             if (type == SkType_Array) {
                 SkDisplayArray* dispArray = (SkDisplayArray*) this;
                 elementType = dispArray->values.getType();
             } else
                 elementType = info->arrayType();
             bool firstElem = true;
             SkDebugf("%s=\"[", info->fName);
             for (SkOperand* op = array->begin(); op < array->end(); op++) {
@@ skipping 53 matching lines @@
 }
 
 void SkDisplayable::dumpChildren(SkAnimateMaker* maker, bool closedAngle) {
 
     int index = -1;
     const SkMemberInfo* info;
     index = -1;
     SkDisplayList::fIndent += 4;
     do {
         info = this->getMember(++index);
-        if (NULL == info) {
+        if (nullptr == info) {
             break;
         }
         if (SkDisplayType::IsDisplayable(maker, info->fType)) {
             SkDisplayable** displayable = (SkDisplayable**) info->memberData(this);
-            if (*displayable == NULL || *displayable == (SkDisplayable*) -1)
+            if (*displayable == nullptr || *displayable == (SkDisplayable*) -1)
                 continue;
             if (closedAngle == false) {
                 SkDebugf(">\n");
                 closedAngle = true;
             }
             (*displayable)->dump(maker);
         }
     } while (true);
     SkDisplayList::fIndent -= 4;
     if (closedAngle)
@@ skipping 137 matching lines @@
     SkASSERT(0);
 }
 
 void SkDisplayable::getBounds(SkRect* rect) {
     SkASSERT(rect);
     rect->fLeft = rect->fTop = SK_ScalarMax;
     rect->fRight= rect->fBottom = -SK_ScalarMax;
 }
 
 const SkFunctionParamType* SkDisplayable::getFunctionsParameters() {
-    return NULL;
+    return nullptr;
 }
 
 const SkMemberInfo* SkDisplayable::getMember(int index) {
-    return NULL;
+    return nullptr;
 }
 
 const SkMemberInfo* SkDisplayable::getMember(const char name[]) {
-    return NULL;
+    return nullptr;
 }
 
 const SkFunctionParamType* SkDisplayable::getParameters(const SkMemberInfo* info,
         int* paramCount) {
     const SkFunctionParamType* params = getFunctionsParameters();
-    SkASSERT(params != NULL);
+    SkASSERT(params != nullptr);
     int funcIndex = info->functionIndex();
     // !!! eventually break traversing params into an external function (maybe this whole function)
     int index = funcIndex;
     int offset = 0;
     while (--index >= 0) {
         while (params[offset] != 0)
             offset++;
         offset++;
     }
     int count = 0;
     while (params[offset] != 0) {
         count++;
         offset++;
     }
     *paramCount = count;
     return &params[offset - count];
 }
 
 SkDisplayable* SkDisplayable::getParent() const {
-    return NULL;
+    return nullptr;
 }
 
 bool SkDisplayable::getProperty(int index, SkScriptValue* ) const {
 //  SkASSERT(0);
     return false;
 }
 
 bool SkDisplayable::getProperty2(int index, SkOperand2* value) const {
     SkASSERT(0);
     return false;
 }
 
 SkDisplayTypes SkDisplayable::getType() const {
     return SkType_Unknown;
 }
 
 bool SkDisplayable::hasEnable() const {
     return false;
 }
 
 bool SkDisplayable::isDrawable() const {
     return false;
 }
 
 void SkDisplayable::onEndElement(SkAnimateMaker& ) {}
 
 const SkMemberInfo* SkDisplayable::preferredChild(SkDisplayTypes type) {
-    return NULL;
+    return nullptr;
 }
 
 bool SkDisplayable::resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* apply) {
     return false;
 }
 
 //SkDisplayable* SkDisplayable::resolveTarget(SkAnimateMaker& ) {
 //  return this;
 //}
 
@@ skipping 33 matching lines @@
     }
 // !!! unclear why displayable is dirtied here
 // if this is called, this breaks fromPath.xml
 //  displayable->dirty();
 }
 
 #ifdef SK_DEBUG
 void SkDisplayable::validate() {
 }
 #endif