Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/event_router.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 237 matching lines @@
                                   listener->GetBrowserContext());
   std::string base_event_name = GetBaseEventName(listener->event_name());
   ObserverMap::iterator observer = observers_.find(base_event_name);
   if (observer != observers_.end())
     observer->second->OnListenerRemoved(details);
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   bool is_new = listeners_.AddListener(EventListener::ForExtension(
-      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+      event_name, extension_id, nullptr, scoped_ptr<DictionaryValue>()));
 
   if (is_new) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
                                           const std::string& extension_id) {
   scoped_ptr<EventListener> listener = EventListener::ForExtension(
-      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>());
+      event_name, extension_id, nullptr, scoped_ptr<DictionaryValue>());
   bool did_exist = listeners_.RemoveListener(listener.get());
 
   if (did_exist) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::AddFilteredEventListener(const std::string& event_name,
                                            content::RenderProcessHost* process,
                                            const std::string& extension_id,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(EventListener::ForExtension(
       event_name,
       extension_id,
       process,
       scoped_ptr<DictionaryValue>(filter.DeepCopy())));
 
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(EventListener::ForExtension(
         event_name,
         extension_id,
-        NULL,
+        nullptr,
         scoped_ptr<DictionaryValue>(filter.DeepCopy())));
 
     if (added)
       AddFilterToEvent(event_name, extension_id, &filter);
   }
 }
 
 void EventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
@@ skipping 41 matching lines @@
        listener != listeners.end(); ++listener) {
     if (listener->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 std::set<std::string> EventRouter::GetRegisteredEvents(
     const std::string& extension_id) {
   std::set<std::string> events;
-  const ListValue* events_value = NULL;
+  const ListValue* events_value = nullptr;
 
   if (!extension_prefs_ ||
       !extension_prefs_->ReadPrefAsList(
            extension_id, kRegisteredEvents, &events_value)) {
     return events;
   }
 
   for (size_t i = 0; i < events_value->GetSize(); ++i) {
     std::string event;
     if (events_value->GetString(i, &event))
@@ skipping 15 matching lines @@
 
 void EventRouter::AddFilterToEvent(const std::string& event_name,
                                    const std::string& extension_id,
                                    const DictionaryValue* filter) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
       extension_prefs_, extension_id, kFilteredEvents);
   DictionaryValue* filtered_events = update.Get();
   if (!filtered_events)
     filtered_events = update.Create();
 
-  ListValue* filter_list = NULL;
+  ListValue* filter_list = nullptr;
   if (!filtered_events->GetList(event_name, &filter_list)) {
     filter_list = new ListValue;
     filtered_events->SetWithoutPathExpansion(event_name, filter_list);
   }
 
   filter_list->Append(filter->DeepCopy());
 }
 
 void EventRouter::RemoveFilterFromEvent(const std::string& event_name,
                                         const std::string& extension_id,
                                         const DictionaryValue* filter) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
       extension_prefs_, extension_id, kFilteredEvents);
   DictionaryValue* filtered_events = update.Get();
-  ListValue* filter_list = NULL;
+  ListValue* filter_list = nullptr;
   if (!filtered_events ||
       !filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
     return;
   }
 
   for (size_t i = 0; i < filter_list->GetSize(); i++) {
-    DictionaryValue* filter = NULL;
+    DictionaryValue* filter = nullptr;
     CHECK(filter_list->GetDictionary(i, &filter));
     if (filter->Equals(filter)) {
-      filter_list->Remove(i, NULL);
+      filter_list->Remove(i, nullptr);
       break;
     }
   }
 }
 
 const DictionaryValue* EventRouter::GetFilteredEvents(
     const std::string& extension_id) {
-  const DictionaryValue* events = NULL;
+  const DictionaryValue* events = nullptr;
   extension_prefs_->ReadPrefAsDictionary(
       extension_id, kFilteredEvents, &events);
   return events;
 }
 
 void EventRouter::BroadcastEvent(scoped_ptr<Event> event) {
   DispatchEventImpl(std::string(), linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
@@ skipping 320 matching lines @@
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   // Remove all registered lazy listeners from our cache.
   listeners_.RemoveLazyListenersForExtension(extension->id());
 }
 
 Event::Event(const std::string& event_name,
              scoped_ptr<base::ListValue> event_args)
     : event_name(event_name),
       event_args(event_args.Pass()),
-      restrict_to_browser_context(NULL),
+      restrict_to_browser_context(nullptr),
       user_gesture(EventRouter::USER_GESTURE_UNKNOWN) {
   DCHECK(this->event_args.get());
 }
 
 Event::Event(const std::string& event_name,
              scoped_ptr<base::ListValue> event_args,
              BrowserContext* restrict_to_browser_context)
     : event_name(event_name),
       event_args(event_args.Pass()),
       restrict_to_browser_context(restrict_to_browser_context),
@@ skipping 33 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions