Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/core/inspector/AsyncCallStackTracker.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 84 matching lines @@
 
     void removeEventListenerData(EventTarget* eventTarget, const AtomicString& eventType, const RegisteredEventListener& item)
     {
         findEventListenerData(eventTarget, eventType, item, true);
     }
 
     PassRefPtr<AsyncCallChain> findEventListenerData(EventTarget* eventTarget, const AtomicString& eventType, const RegisteredEventListener& item, bool remove = false)
     {
         HashMap<EventTarget*, EventListenerAsyncCallChainVectorHashMap>::iterator it = m_eventTargetCallChains.find(eventTarget);
         if (it == m_eventTargetCallChains.end())
-            return 0;
+            return nullptr;
         EventListenerAsyncCallChainVectorHashMap& map = it->value;
         EventListenerAsyncCallChainVectorHashMap::iterator it2 = map.find(eventType);
         if (it2 == map.end())
-            return 0;
+            return nullptr;
         RefPtr<AsyncCallChain> result;
         EventListenerAsyncCallChainVector& vector = it2->value;
         for (size_t i = 0; i < vector.size(); ++i) {
             if (vector[i].first == item) {
                 result = vector[i].second;
                 if (remove) {
                     vector.remove(i);
                     if (vector.isEmpty())
                         map.remove(it2);
                     if (map.isEmpty())
@@ skipping 89 matching lines @@
     ASSERT(context);
     ASSERT(isEnabled());
     ASSERT(timerId > 0);
     ASSERT(!m_currentAsyncCallChain);
     if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
         if (data->m_intervalTimerIds.contains(timerId))
             setCurrentAsyncCallChain(data->m_timerCallChains.get(timerId));
         else
             setCurrentAsyncCallChain(data->m_timerCallChains.take(timerId));
     } else {
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
     }
 }
 
 void AsyncCallStackTracker::didRequestAnimationFrame(ExecutionContext* context, int callbackId, const ScriptValue& callFrames)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (!validateCallFrames(callFrames))
         return;
     ASSERT(callbackId > 0);
@@ skipping 13 matching lines @@
 
 void AsyncCallStackTracker::willFireAnimationFrame(ExecutionContext* context, int callbackId)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     ASSERT(callbackId > 0);
     ASSERT(!m_currentAsyncCallChain);
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
         setCurrentAsyncCallChain(data->m_animationFrameCallChains.take(callbackId));
     else
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
 }
 
 void AsyncCallStackTracker::didAddEventListener(EventTarget* eventTarget, const AtomicString& eventType, EventListener* listener, bool useCapture, const ScriptValue& callFrames)
 {
     ASSERT(eventTarget->executionContext());
     ASSERT(isEnabled());
     if (!validateCallFrames(callFrames) || toXmlHttpRequest(eventTarget))
         return;
 
     StringBuilder description;
@@ skipping 33 matching lines @@
 {
     ASSERT(eventTarget->executionContext());
     ASSERT(isEnabled());
     if (XMLHttpRequest* xhr = toXmlHttpRequest(eventTarget)) {
         willHandleXHREvent(xhr, eventTarget, eventType);
         return;
     }
     if (ExecutionContextData* data = m_executionContextDataMap.get(eventTarget->executionContext()))
         setCurrentAsyncCallChain(data->findEventListenerData(eventTarget, eventType, RegisteredEventListener(listener, useCapture)));
     else
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
 }
 
 void AsyncCallStackTracker::willLoadXHR(XMLHttpRequest* xhr, const ScriptValue& callFrames)
 {
     ASSERT(xhr->executionContext());
     ASSERT(isEnabled());
     if (!validateCallFrames(callFrames))
         return;
     ExecutionContextData* data = createContextDataIfNeeded(xhr->executionContext());
     data->m_xhrCallChains.set(xhr, createAsyncCallChain(xhrSendName, callFrames));
 }
 
 void AsyncCallStackTracker::willHandleXHREvent(XMLHttpRequest* xhr, EventTarget* eventTarget, const AtomicString& eventType)
 {
     ASSERT(xhr->executionContext());
     ASSERT(isEnabled());
     if (ExecutionContextData* data = m_executionContextDataMap.get(xhr->executionContext())) {
         bool isXHRDownload = (xhr == eventTarget);
         if (isXHRDownload && eventType == EventTypeNames::loadend)
             setCurrentAsyncCallChain(data->m_xhrCallChains.take(xhr));
         else
             setCurrentAsyncCallChain(data->m_xhrCallChains.get(xhr));
     } else {
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
     }
 }
 
 void AsyncCallStackTracker::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer, const ScriptValue& callFrames)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (!validateCallFrames(callFrames))
         return;
     ExecutionContextData* data = createContextDataIfNeeded(context);
@@ skipping 17 matching lines @@
         data->m_mutationObserverCallChains.remove(observer);
 }
 
 void AsyncCallStackTracker::willDeliverMutationRecords(ExecutionContext* context, MutationObserver* observer)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
         setCurrentAsyncCallChain(data->m_mutationObserverCallChains.take(observer));
     else
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
 }
 
 void AsyncCallStackTracker::didPostPromiseTask(ExecutionContext* context, ExecutionContextTask* task, bool isResolved, const ScriptValue& callFrames)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (validateCallFrames(callFrames)) {
         ExecutionContextData* data = createContextDataIfNeeded(context);
         data->m_promiseTaskCallChains.set(task, createAsyncCallChain(isResolved ? promiseResolved : promiseRejected, callFrames));
     } else if (m_currentAsyncCallChain) {
         // Propagate async call stack to the re-posted task to update a derived Promise.
         ExecutionContextData* data = createContextDataIfNeeded(context);
         data->m_promiseTaskCallChains.set(task, m_currentAsyncCallChain);
     }
 }
 
 void AsyncCallStackTracker::willPerformPromiseTask(ExecutionContext* context, ExecutionContextTask* task)
 {
     ASSERT(context);
     ASSERT(isEnabled());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
         setCurrentAsyncCallChain(data->m_promiseTaskCallChains.take(task));
     else
-        setCurrentAsyncCallChain(0);
+        setCurrentAsyncCallChain(nullptr);
 }
 
 void AsyncCallStackTracker::didFireAsyncCall()
 {
     clearCurrentAsyncCallChain();
 }
 
 PassRefPtr<AsyncCallStackTracker::AsyncCallChain> AsyncCallStackTracker::createAsyncCallChain(const String& description, const ScriptValue& callFrames)
 {
     RefPtr<AsyncCallChain> chain = adoptRef(m_currentAsyncCallChain ? new AsyncCallStackTracker::AsyncCallChain(*m_currentAsyncCallChain) : new AsyncCallStackTracker::AsyncCallChain());
@@ skipping 48 matching lines @@
 {
     m_currentAsyncCallChain.clear();
     m_nestedAsyncCallCount = 0;
     ExecutionContextDataMap copy;
     m_executionContextDataMap.swap(copy);
     for (ExecutionContextDataMap::const_iterator it = copy.begin(); it != copy.end(); ++it)
         delete it->value;
 }
 
 } // namespace WebCore