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

extensions/browser/event_listener_map.cc

 // Copyright 2013 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_listener_map.h"
 
 #include "base/values.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/event_router.h"
 #include "ipc/ipc_message.h"
@@ skipping 44 matching lines @@
     filter_copy.reset(filter_->DeepCopy());
   return scoped_ptr<EventListener>(new EventListener(
       event_name_, extension_id_, listener_url_, process_, filter_copy.Pass()));
 }
 
 bool EventListener::IsLazy() const {
   return !process_;
 }
 
 void EventListener::MakeLazy() {
-  process_ = NULL;
+  process_ = nullptr;
 }
 
 content::BrowserContext* EventListener::GetBrowserContext() const {
-  return process_ ? process_->GetBrowserContext() : NULL;
+  return process_ ? process_->GetBrowserContext() : nullptr;
 }
 
 EventListener::EventListener(const std::string& event_name,
                              const std::string& extension_id,
                              const GURL& listener_url,
                              content::RenderProcessHost* process,
                              scoped_ptr<DictionaryValue> filter)
     : event_name_(event_name),
       extension_id_(extension_id),
       listener_url_(listener_url),
@@ skipping 111 matching lines @@
     }
   }
 }
 
 void EventListenerMap::LoadUnfilteredLazyListeners(
     const std::string& extension_id,
     const std::set<std::string>& event_names) {
   for (std::set<std::string>::const_iterator it = event_names.begin();
        it != event_names.end(); ++it) {
     AddListener(EventListener::ForExtension(
-        *it, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+        *it, extension_id, nullptr, scoped_ptr<DictionaryValue>()));
   }
 }
 
 void EventListenerMap::LoadFilteredLazyListeners(
     const std::string& extension_id,
     const DictionaryValue& filtered) {
   for (DictionaryValue::Iterator it(filtered); !it.IsAtEnd(); it.Advance()) {
     // We skip entries if they are malformed.
-    const base::ListValue* filter_list = NULL;
+    const base::ListValue* filter_list = nullptr;
     if (!it.value().GetAsList(&filter_list))
       continue;
     for (size_t i = 0; i < filter_list->GetSize(); i++) {
-      const DictionaryValue* filter = NULL;
+      const DictionaryValue* filter = nullptr;
       if (!filter_list->GetDictionary(i, &filter))
         continue;
-      AddListener(EventListener::ForExtension(
-          it.key(), extension_id, NULL, make_scoped_ptr(filter->DeepCopy())));
+      AddListener(
+          EventListener::ForExtension(it.key(),
+                                      extension_id,
+                                      nullptr,
+                                      make_scoped_ptr(filter->DeepCopy())));
     }
   }
 }
 
 std::set<const EventListener*> EventListenerMap::GetEventListeners(
     const Event& event) {
   std::set<const EventListener*> interested_listeners;
   if (IsFilteredEvent(event)) {
     // Look up the interested listeners via the EventFilter.
     std::set<MatcherID> ids =
@@ skipping 41 matching lines @@
     return;
   event_filter_.RemoveEventMatcher(listener->matcher_id());
   CHECK_EQ(1u, listeners_by_matcher_id_.erase(listener->matcher_id()));
 }
 
 bool EventListenerMap::IsFilteredEvent(const Event& event) const {
   return filtered_events_.count(event.event_name) > 0u;
 }
 
 }  // namespace extensions