Style Change: NULL->nullptr

src/animator/SkAnimateMaker.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 "SkAnimateMaker.h"
@@ skipping 10 matching lines @@
 #include "SkSystemEventTypes.h"
 #include "SkTime.h"
 
 class DefaultTimeline : public SkAnimator::Timeline {
     virtual SkMSec getMSecs() const {
         return SkTime::GetMSecs();
     }
 } gDefaultTimeline;
 
 SkAnimateMaker::SkAnimateMaker(SkAnimator* animator, SkCanvas* canvas, SkPaint* paint)
-    : fActiveEvent(NULL), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0),
-        fHostEventSinkID(0), fMinimumInterval((SkMSec) -1), fPaint(paint), fParentMaker(NULL),
+    : fActiveEvent(nullptr), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0),
+        fHostEventSinkID(0), fMinimumInterval((SkMSec) -1), fPaint(paint), fParentMaker(nullptr),
         fTimeline(&gDefaultTimeline), fInInclude(false), fInMovie(false),
         fFirstScriptError(false), fLoaded(false), fIDs(256), fAnimator(animator)
 {
     fScreenplay.time = 0;
 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
     fDebugTimeBase = (SkMSec) -1;
 #endif
 #ifdef SK_DUMP_ENABLED
     fDumpEvents = fDumpGConditions = fDumpPosts = false;
 #endif
@@ skipping 16 matching lines @@
 
 void SkAnimateMaker::appendActive(SkActive* active) {
     fDisplayList.append(active);
 }
 
 void SkAnimateMaker::clearExtraPropertyCallBack(SkDisplayTypes type) {
     SkExtras** end = fExtras.end();
     for (SkExtras** extraPtr = fExtras.begin(); extraPtr < end; extraPtr++) {
         SkExtras* extra = *extraPtr;
         if (extra->definesType(type)) {
-            extra->fExtraCallBack = NULL;
-            extra->fExtraStorage = NULL;
+            extra->fExtraCallBack = nullptr;
+            extra->fExtraStorage = nullptr;
             break;
         }
     }
 }
 
 bool SkAnimateMaker::computeID(SkDisplayable* displayable, SkDisplayable* parent, SkString* newID) {
     const char* script;
   if (findKey(displayable, &script) == false)
         return true;
     return SkAnimatorScript::EvaluateString(*this, displayable, parent, script, newID);
 }
 
 SkDisplayable* SkAnimateMaker::createInstance(const char name[], size_t len) {
     SkDisplayTypes type = SkDisplayType::GetType(this, name, len );
     if ((int)type >= 0)
         return SkDisplayType::CreateInstance(this, type);
-    return NULL;
+    return nullptr;
 }
 
 // differs from SkAnimator::decodeStream in that it does not reset error state
 bool SkAnimateMaker::decodeStream(SkStream* stream)
 {
     SkDisplayXMLParser parser(*this);
     return parser.parse(*stream);
 }
 
 // differs from SkAnimator::decodeURI in that it does not set URI base
@@ skipping 76 matching lines @@
 
 bool SkAnimateMaker::doEvent(const SkEvent& event) {
     return (!fInMovie || fLoaded) && fAnimator->doEvent(event);
 }
 
 #ifdef SK_DUMP_ENABLED
 void SkAnimateMaker::dump(const char* match) {
         SkTDict<SkDisplayable*>::Iter iter(fIDs);
         const char* name;
         SkDisplayable* result;
-        while ((name = iter.next(&result)) != NULL) {
+        while ((name = iter.next(&result)) != nullptr) {
             if (strcmp(match,name) == 0)
                 result->dump(this);
         }
 }
 #endif
 
 int SkAnimateMaker::dynamicProperty(SkString& nameStr, SkDisplayable** displayablePtr ) {
     const char* name = nameStr.c_str();
     const char* dot = strchr(name, '.');
     SkASSERT(dot);
@@ skipping 11 matching lines @@
 SkMSec SkAnimateMaker::getAppTime() const {
     return fTimeline->getMSecs();
 }
 
 #ifdef SK_DEBUG
 SkAnimator* SkAnimateMaker::getRoot()
 {
     SkAnimateMaker* maker = this;
     while (maker->fParentMaker)
         maker = maker->fParentMaker;
-    return maker == this ? NULL : maker->fAnimator;
+    return maker == this ? nullptr : maker->fAnimator;
 }
 #endif
 
 void SkAnimateMaker::helperAdd(SkDisplayable* trackMe) {
     SkASSERT(fHelpers.find(trackMe) < 0);
     *fHelpers.append() = trackMe;
 }
 
 void SkAnimateMaker::helperRemove(SkDisplayable* alreadyTracked) {
     int helperIndex = fHelpers.find(alreadyTracked);
     if (helperIndex >= 0)
         fHelpers.remove(helperIndex);
 }
 
 #if 0
 void SkAnimateMaker::loadMovies() {
     for (SkDisplayable** dispPtr = fMovies.begin(); dispPtr < fMovies.end(); dispPtr++) {
         SkDisplayable* displayable = *dispPtr;
         SkASSERT(displayable->getType() == SkType_Movie);
         SkDisplayMovie* movie = (SkDisplayMovie*) displayable;
         SkAnimateMaker* movieMaker = movie->fMovie.fMaker;
-        movieMaker->fEvents.doEvent(*movieMaker, SkDisplayEvent::kOnload, NULL);
-        movieMaker->fEvents.removeEvent(SkDisplayEvent::kOnload, NULL);
+        movieMaker->fEvents.doEvent(*movieMaker, SkDisplayEvent::kOnload, nullptr);
+        movieMaker->fEvents.removeEvent(SkDisplayEvent::kOnload, nullptr);
         movieMaker->loadMovies();
     }
 }
 #endif
 
 void SkAnimateMaker::notifyInval() {
     if (fHostEventSinkID)
         fAnimator->onEventPost(new SkEvent(SK_EventType_Inval), fHostEventSinkID);
 }
 
@@ skipping 14 matching lines @@
 void SkAnimateMaker::reset() {
     deleteMembers();
     fChildren.reset();
     fHelpers.reset();
     fIDs.reset();
     fEvents.reset();
     fDisplayList.hardReset();
 }
 
 void SkAnimateMaker::removeActive(SkActive* active) {
-    if (active == NULL)
+    if (active == nullptr)
         return;
     fDisplayList.remove(active);
 }
 
 bool SkAnimateMaker::resolveID(SkDisplayable* displayable, SkDisplayable* original) {
     SkString newID;
-    bool success = computeID(original, NULL, &newID);
+    bool success = computeID(original, nullptr, &newID);
     if (success)
         setID(displayable, newID);
     return success;
 }
 
 void SkAnimateMaker::setErrorString() {
     fErrorString.reset();
     if (fError.hasError()) {
         SkString err;
         if (fFileName.size() > 0)
@@ skipping 71 matching lines @@
 }
 
 bool SkAnimateMaker::GetStep(const char* token, size_t len, void* stepPtr, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL("step", token, len)) {
         value->fOperand.fS32 = *(int32_t*) stepPtr;
         value->fType = SkType_Int;
         return true;
     }
     return false;
 }