Style Change: NULL->nullptr

src/views/SkEvent.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 "SkEvent.h"
 
 void SkEvent::initialize(const char* type, size_t typeLen,
                          SkEventSinkID targetID) {
-    fType = NULL;
+    fType = nullptr;
     setType(type, typeLen);
     f32 = 0;
     fTargetID = targetID;
-    fTargetProc = NULL;
+    fTargetProc = nullptr;
 #ifdef SK_DEBUG
     fTime = 0;
-    fNextEvent = NULL;
+    fNextEvent = nullptr;
 #endif
 }
 
 SkEvent::SkEvent()
 {
     initialize("", 0, 0);
 }
 
 SkEvent::SkEvent(const SkEvent& src)
 {
@@ skipping 89 matching lines @@
 
 #include "SkParse.h"
 
 void SkEvent::inflate(const SkDOM& dom, const SkDOM::Node* node)
 {
     const char* name = dom.findAttr(node, "type");
     if (name)
         this->setType(name);
 
     const char* value;
-    if ((value = dom.findAttr(node, "fast32")) != NULL)
+    if ((value = dom.findAttr(node, "fast32")) != nullptr)
     {
         int32_t n;
         if (SkParse::FindS32(value, &n))
             this->setFast32(n);
     }
 
     for (node = dom.getFirstChild(node); node; node = dom.getNextSibling(node))
     {
         if (strcmp(dom.getName(node), "data"))
         {
             SkDEBUGCODE(SkDebugf("SkEvent::inflate unrecognized subelement <%s>\n", dom.getName(node));)
             continue;
         }
 
         name = dom.findAttr(node, "name");
-        if (name == NULL)
+        if (name == nullptr)
         {
             SkDEBUGCODE(SkDebugf("SkEvent::inflate missing required \"name\" attribute in <data> subelement\n");)
             continue;
         }
 
-        if ((value = dom.findAttr(node, "s32")) != NULL)
+        if ((value = dom.findAttr(node, "s32")) != nullptr)
         {
             int32_t n;
             if (SkParse::FindS32(value, &n))
                 this->setS32(name, n);
         }
-        else if ((value = dom.findAttr(node, "scalar")) != NULL)
+        else if ((value = dom.findAttr(node, "scalar")) != nullptr)
         {
             SkScalar x;
             if (SkParse::FindScalar(value, &x))
                 this->setScalar(name, x);
         }
-        else if ((value = dom.findAttr(node, "string")) != NULL)
+        else if ((value = dom.findAttr(node, "string")) != nullptr)
             this->setString(name, value);
 #ifdef SK_DEBUG
         else
         {
             SkDebugf("SkEvent::inflate <data name=\"%s\"> subelement missing required type attribute [S32 | scalar | string]\n", name);
         }
 #endif
     }
 }
 
@@ skipping 11 matching lines @@
         SkString    etype;
         this->getType(&etype);
         SkDebugf("event<%s> fast32=%d", etype.c_str(), this->getFast32());
 
         const SkMetaData&   md = this->getMetaData();
         SkMetaData::Iter    iter(md);
         SkMetaData::Type    mtype;
         int                 count;
         const char*         name;
 
-        while ((name = iter.next(&mtype, &count)) != NULL)
+        while ((name = iter.next(&mtype, &count)) != nullptr)
         {
             SkASSERT(count > 0);
 
             SkDebugf(" <%s>=", name);
             switch (mtype) {
             case SkMetaData::kS32_Type:     // vector version???
                 {
                     int32_t value;
                     md.findS32(name, &value);
                     SkDebugf("%d ", value);
                 }
                 break;
             case SkMetaData::kScalar_Type:
                 {
-                    const SkScalar* values = md.findScalars(name, &count, NULL);
+                    const SkScalar* values = md.findScalars(name, &count, nullptr);
                     SkDebugf("%f", SkScalarToFloat(values[0]));
                     for (int i = 1; i < count; i++)
                         SkDebugf(", %f", SkScalarToFloat(values[i]));
                     SkDebugf(" ");
                 }
                 break;
             case SkMetaData::kString_Type:
                 {
                     const char* value = md.findString(name);
                     SkASSERT(value);
@@ skipping 41 matching lines @@
     #define EVENT_LOG(s)
     #define EVENT_LOGN(s, n)
 #endif
 
 #include "SkMutex.h"
 #include "SkTime.h"
 
 class SkEvent_Globals {
 public:
     SkEvent_Globals() {
-        fEventQHead = NULL;
-        fEventQTail = NULL;
-        fDelayQHead = NULL;
+        fEventQHead = nullptr;
+        fEventQTail = nullptr;
+        fDelayQHead = nullptr;
         SkDEBUGCODE(fEventCounter = 0;)
     }
 
     SkMutex     fEventMutex;
     SkEvent*    fEventQHead, *fEventQTail;
     SkEvent*    fDelayQHead;
     SkDEBUGCODE(int fEventCounter;)
 };
 
 static SkEvent_Globals& getGlobals() {
@@ skipping 44 matching lines @@
         SkEvent::SignalQueueTimer(queueDelay);
     }
 }
 
 bool SkEvent::Enqueue(SkEvent* evt) {
     SkEvent_Globals& globals = getGlobals();
     //  gEventMutex acquired by caller
 
     SkASSERT(evt);
 
-    bool wasEmpty = globals.fEventQHead == NULL;
+    bool wasEmpty = globals.fEventQHead == nullptr;
 
     if (globals.fEventQTail)
         globals.fEventQTail->fNextEvent = evt;
     globals.fEventQTail = evt;
-    if (globals.fEventQHead == NULL)
+    if (globals.fEventQHead == nullptr)
         globals.fEventQHead = evt;
-    evt->fNextEvent = NULL;
+    evt->fNextEvent = nullptr;
 
     SkDEBUGCODE(++globals.fEventCounter);
 
     return wasEmpty;
 }
 
 SkEvent* SkEvent::Dequeue() {
     SkEvent_Globals& globals = getGlobals();
     globals.fEventMutex.acquire();
 
     SkEvent* evt = globals.fEventQHead;
     if (evt) {
         SkDEBUGCODE(--globals.fEventCounter);
 
         globals.fEventQHead = evt->fNextEvent;
-        if (globals.fEventQHead == NULL) {
-            globals.fEventQTail = NULL;
+        if (globals.fEventQHead == nullptr) {
+            globals.fEventQTail = nullptr;
         }
     }
     globals.fEventMutex.release();
 
     return evt;
 }
 
 bool SkEvent::QHasEvents() {
     SkEvent_Globals& globals = getGlobals();
 
     // this is not thread accurate, need a semaphore for that
-    return globals.fEventQHead != NULL;
+    return globals.fEventQHead != nullptr;
 }
 
 #ifdef SK_TRACE_EVENTS
     static int gDelayDepth;
 #endif
 
 SkMSec SkEvent::EnqueueTime(SkEvent* evt, SkMSec time) {
     SkEvent_Globals& globals = getGlobals();
     //  gEventMutex acquired by caller
 
     SkEvent* curr = globals.fDelayQHead;
-    SkEvent* prev = NULL;
+    SkEvent* prev = nullptr;
 
     while (curr) {
         if (SkMSec_LT(time, curr->fTime)) {
             break;
         }
         prev = curr;
         curr = curr->fNextEvent;
     }
 
     evt->fTime = time;
     evt->fNextEvent = curr;
-    if (prev == NULL) {
+    if (prev == nullptr) {
         globals.fDelayQHead = evt;
     } else {
         prev->fNextEvent = evt;
     }
 
     SkMSec delay = globals.fDelayQHead->fTime - SkTime::GetMSecs();
     if ((int32_t)delay <= 0) {
         delay = 1;
     }
     return delay;
@@ skipping 87 matching lines @@
         evt = next;
     }
 
     evt = globals.fDelayQHead;
     while (evt) {
         SkEvent* next = evt->fNextEvent;
         delete evt;
         evt = next;
     }
 }