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

extensions/browser/api/declarative/declarative_api.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/declarative_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/task_runner_util.h"
@@ skipping 54 matching lines @@
 }
 
 // Parses through |args| replacing any BinaryValues with base64 encoded
 // StringValues. Recurses over any nested ListValues, and calls
 // ConvertBinaryDictionaryValuesToBase64 for any nested DictionaryValues.
 void ConvertBinaryListElementsToBase64(base::ListValue* args) {
   size_t index = 0;
   for (base::ListValue::iterator iter = args->begin(); iter != args->end();
        ++iter, ++index) {
     if ((*iter)->IsType(base::Value::TYPE_BINARY)) {
-      base::BinaryValue* binary = NULL;
+      base::BinaryValue* binary = nullptr;
       if (args->GetBinary(index, &binary))
         args->Set(index, ConvertBinaryToBase64(binary).release());
     } else if ((*iter)->IsType(base::Value::TYPE_LIST)) {
       base::ListValue* list;
       (*iter)->GetAsList(&list);
       ConvertBinaryListElementsToBase64(list);
     } else if ((*iter)->IsType(base::Value::TYPE_DICTIONARY)) {
       base::DictionaryValue* dict;
       (*iter)->GetAsDictionary(&dict);
       ConvertBinaryDictionaryValuesToBase64(dict);
     }
   }
 }
 
 // Parses through |dict| replacing any BinaryValues with base64 encoded
 // StringValues. Recurses over any nested DictionaryValues, and calls
 // ConvertBinaryListElementsToBase64 for any nested ListValues.
 void ConvertBinaryDictionaryValuesToBase64(base::DictionaryValue* dict) {
   for (base::DictionaryValue::Iterator iter(*dict); !iter.IsAtEnd();
        iter.Advance()) {
     if (iter.value().IsType(base::Value::TYPE_BINARY)) {
-      base::BinaryValue* binary = NULL;
+      base::BinaryValue* binary = nullptr;
       if (dict->GetBinary(iter.key(), &binary))
         dict->Set(iter.key(), ConvertBinaryToBase64(binary).release());
     } else if (iter.value().IsType(base::Value::TYPE_LIST)) {
       const base::ListValue* list;
       iter.value().GetAsList(&list);
       ConvertBinaryListElementsToBase64(const_cast<base::ListValue*>(list));
     } else if (iter.value().IsType(base::Value::TYPE_DICTIONARY)) {
       const base::DictionaryValue* dict;
       iter.value().GetAsDictionary(&dict);
       ConvertBinaryDictionaryValuesToBase64(
           const_cast<base::DictionaryValue*>(dict));
     }
   }
 }
 
 }  // namespace
 
-RulesFunction::RulesFunction()
-    : rules_registry_(NULL) {
+RulesFunction::RulesFunction() : rules_registry_(nullptr) {
 }
 
 RulesFunction::~RulesFunction() {}
 
 bool RulesFunction::HasPermission() {
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
   if (IsWebViewEvent(event_name) &&
       extension_->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kWebView))
@@ skipping 88 matching lines @@
   } else {
     rules_registry_->GetAllRules(extension_id(), &rules);
   }
 
   results_ = GetRules::Results::Create(rules);
 
   return true;
 }
 
 }  // namespace extensions