Style Change: NULL->nullptr

src/views/SkEventSink.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 "SkEventSink.h"
 #include "SkMutex.h"
 #include "SkTagList.h"
 #include "SkTime.h"
 
 class SkEventSink_Globals {
 public:
     SkEventSink_Globals() {
         fNextSinkID = 0;
-        fSinkHead = NULL;
+        fSinkHead = nullptr;
     }
 
     SkMutex         fSinkMutex;
     SkEventSinkID   fNextSinkID;
     SkEventSink*    fSinkHead;
 };
 
 static SkEventSink_Globals& getGlobals() {
     // leak this, so we don't incur any shutdown perf hit
     static SkEventSink_Globals* gGlobals = new SkEventSink_Globals;
     return *gGlobals;
 }
 
-SkEventSink::SkEventSink() : fTagHead(NULL) {
+SkEventSink::SkEventSink() : fTagHead(nullptr) {
     SkEventSink_Globals& globals = getGlobals();
 
     globals.fSinkMutex.acquire();
 
     fID = ++globals.fNextSinkID;
     fNextSink = globals.fSinkHead;
     globals.fSinkHead = this;
 
     globals.fSinkMutex.release();
 }
 
 SkEventSink::~SkEventSink() {
     SkEventSink_Globals& globals = getGlobals();
 
     if (fTagHead)
         SkTagList::DeleteAll(fTagHead);
 
     globals.fSinkMutex.acquire();
 
     SkEventSink* sink = globals.fSinkHead;
-    SkEventSink* prev = NULL;
+    SkEventSink* prev = nullptr;
 
     for (;;) {
         SkEventSink* next = sink->fNextSink;
         if (sink == this) {
             if (prev) {
                 prev->fNextSink = next;
             } else {
                 globals.fSinkHead = next;
             }
             break;
@@ skipping 17 matching lines @@
     return false;
 }
 
 bool SkEventSink::onQuery(SkEvent*) {
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkTagList* SkEventSink::findTagList(U8CPU tag) const {
-    return fTagHead ? SkTagList::Find(fTagHead, tag) : NULL;
+    return fTagHead ? SkTagList::Find(fTagHead, tag) : nullptr;
 }
 
 void SkEventSink::addTagList(SkTagList* rec) {
     SkASSERT(rec);
-    SkASSERT(fTagHead == NULL || SkTagList::Find(fTagHead, rec->fTag) == NULL);
+    SkASSERT(fTagHead == nullptr || SkTagList::Find(fTagHead, rec->fTag) == nullptr);
 
     rec->fNext = fTagHead;
     fTagHead = rec;
 }
 
 void SkEventSink::removeTagList(U8CPU tag) {
     if (fTagHead) {
         SkTagList::DeleteTag(&fTagHead, tag);
     }
 }
@@ skipping 47 matching lines @@
         memcpy(next->fIDs, prev->fIDs, count * sizeof(SkEventSinkID));
         this->removeTagList(kListeners_SkTagList);
     }
     next->fIDs[count] = id;
     this->addTagList(next);
 }
 
 void SkEventSink::copyListeners(const SkEventSink& sink)
 {
     SkListenersTagList* sinkList = (SkListenersTagList*)sink.findTagList(kListeners_SkTagList);
-    if (sinkList == NULL)
+    if (sinkList == nullptr)
         return;
     SkASSERT(sinkList->countListners() > 0);
     const SkEventSinkID* iter = sinkList->fIDs;
     const SkEventSinkID* stop = iter + sinkList->countListners();
     while (iter < stop)
         addListenerID(*iter++);
 }
 
 void SkEventSink::removeListenerID(SkEventSinkID id)
 {
     if (id == 0)
         return;
 
     SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
 
-    if (list == NULL)
+    if (list == nullptr)
         return;
 
     int index = list->find(id);
     if (index >= 0)
     {
         int count = list->countListners();
         SkASSERT(count > 0);
         if (count == 1)
             this->removeTagList(kListeners_SkTagList);
         else
         {
             // overwrite without resize/reallocating our struct (for speed)
             list->fIDs[index] = list->fIDs[count - 1];
             list->fExtra16 = SkToU16(count - 1);
         }
     }
 }
 
 bool SkEventSink::hasListeners() const
 {
-    return this->findTagList(kListeners_SkTagList) != NULL;
+    return this->findTagList(kListeners_SkTagList) != nullptr;
 }
 
 void SkEventSink::postToListeners(const SkEvent& evt, SkMSec delay) {
     SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
     if (list) {
         SkASSERT(list->countListners() > 0);
         const SkEventSinkID* iter = list->fIDs;
         const SkEventSinkID* stop = iter + list->countListners();
         while (iter < stop) {
             SkEvent* copy = new SkEvent(evt);
@@ skipping 26 matching lines @@
     SkEventSink_Globals&    globals = getGlobals();
     SkAutoMutexAcquire      ac(globals.fSinkMutex);
     SkEventSink*            sink = globals.fSinkHead;
 
     while (sink)
     {
         if (sink->getSinkID() == sinkID)
             return sink;
         sink = sink->fNextSink;
     }
-    return NULL;
+    return nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #if 0   // experimental, not tested
 
 #include "SkMutex.h"
 #include "SkTDict.h"
 
@@ skipping 32 matching lines @@
 /** Remove all name/id pairs from the system. This is call internally
     on shutdown, to ensure no memory leaks. It should not be called
     before shutdown.
 */
 void SkEventSink::RemoveAllNamedSinkIDs()
 {
     SkAutoMutexAcquire  ac(gNamedSinkMutex);
     (void)gNamedSinkIDs.reset();
 }
 #endif