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

extensions/browser/api/declarative/rules_registry.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/api/declarative/rules_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 22 matching lines @@
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < rules.size(); ++i)
     list->Append(rules[i]->ToValue().release());
   return list.PassAs<base::Value>();
 }
 
 std::vector<linked_ptr<extensions::RulesRegistry::Rule> > RulesFromValue(
     const base::Value* value) {
   std::vector<linked_ptr<extensions::RulesRegistry::Rule> > rules;
 
-  const base::ListValue* list = NULL;
+  const base::ListValue* list = nullptr;
   if (!value || !value->GetAsList(&list))
     return rules;
 
   rules.reserve(list->GetSize());
   for (size_t i = 0; i < list->GetSize(); ++i) {
-    const base::DictionaryValue* dict = NULL;
+    const base::DictionaryValue* dict = nullptr;
     if (!list->GetDictionary(i, &dict))
       continue;
     linked_ptr<extensions::RulesRegistry::Rule> rule(
         new extensions::RulesRegistry::Rule());
     if (extensions::RulesRegistry::Rule::Populate(*dict, rule.get()))
       rules.push_back(rule);
   }
 
   return rules;
 }
@@ skipping 13 matching lines @@
                              const std::string& event_name,
                              content::BrowserThread::ID owner_thread,
                              RulesCacheDelegate* cache_delegate,
                              const WebViewKey& webview_key)
     : browser_context_(browser_context),
       owner_thread_(owner_thread),
       event_name_(event_name),
       webview_key_(webview_key),
       ready_(/*signaled=*/!cache_delegate),  // Immediately ready if no cache
                                              // delegate to wait for.
-      weak_ptr_factory_(browser_context_ ? this : NULL),
+      weak_ptr_factory_(browser_context_ ? this : nullptr),
       last_generated_rule_identifier_id_(0) {
   if (cache_delegate) {
     cache_delegate_ = cache_delegate->GetWeakPtr();
     cache_delegate->Init(this);
   }
 }
 
 std::string RulesRegistry::AddRulesNoFill(
     const std::string& extension_id,
     const std::vector<linked_ptr<Rule> >& rules) {
@@ skipping 274 matching lines @@
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions