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

extensions/browser/api/storage/storage_api.cc

 // Copyright 2014 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/storage/storage_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
     // This should be EXTENSION_FUNCTION_VALIDATE(false) but there is no way
     // to signify that from this function. It will be caught in Run().
     return false;
   }
   return settings_namespace_string != "sync";
 }
 
 ExtensionFunction::ResponseAction SettingsFunction::Run() {
   std::string settings_namespace_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &settings_namespace_string));
-  args_->Remove(0, NULL);
+  args_->Remove(0, nullptr);
   settings_namespace_ =
       settings_namespace::FromString(settings_namespace_string);
   EXTENSION_FUNCTION_VALIDATE(settings_namespace_ !=
                               settings_namespace::INVALID);
 
   StorageFrontend* frontend = StorageFrontend::Get(browser_context());
   if (!frontend->IsStorageEnabled(settings_namespace_)) {
     return RespondNow(Error(
         base::StringPrintf("\"%s\" is not available in this instance of Chrome",
                            settings_namespace_string.c_str())));
@@ skipping 114 matching lines @@
       base::TimeDelta::FromMinutes(10),
       shortLimitConfig,
       new QuotaLimitHeuristic::SingletonBucketMapper(),
       "MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE"));
 };
 
 }  // namespace
 
 ExtensionFunction::ResponseValue StorageStorageAreaGetFunction::RunWithStorage(
     ValueStore* storage) {
-  base::Value* input = NULL;
+  base::Value* input = nullptr;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   switch (input->GetType()) {
     case base::Value::TYPE_NULL:
       return UseReadResult(storage->Get(), storage);
 
     case base::Value::TYPE_STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
@@ skipping 22 matching lines @@
           storage);
     }
 
     default:
       return BadMessage();
   }
 }
 
 ExtensionFunction::ResponseValue
 StorageStorageAreaGetBytesInUseFunction::RunWithStorage(ValueStore* storage) {
-  base::Value* input = NULL;
+  base::Value* input = nullptr;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   size_t bytes_in_use = 0;
 
   switch (input->GetType()) {
     case base::Value::TYPE_NULL:
       bytes_in_use = storage->GetBytesInUse();
       break;
 
@@ skipping 15 matching lines @@
     default:
       return BadMessage();
   }
 
   return OneArgument(
       new base::FundamentalValue(static_cast<int>(bytes_in_use)));
 }
 
 ExtensionFunction::ResponseValue StorageStorageAreaSetFunction::RunWithStorage(
     ValueStore* storage) {
-  base::DictionaryValue* input = NULL;
+  base::DictionaryValue* input = nullptr;
   if (!args_->GetDictionary(0, &input))
     return BadMessage();
   return UseWriteResult(storage->Set(ValueStore::DEFAULTS, *input), storage);
 }
 
 void StorageStorageAreaSetFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 ExtensionFunction::ResponseValue
 StorageStorageAreaRemoveFunction::RunWithStorage(ValueStore* storage) {
-  base::Value* input = NULL;
+  base::Value* input = nullptr;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   switch (input->GetType()) {
     case base::Value::TYPE_STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
       return UseWriteResult(storage->Remove(as_string), storage);
     }
 
@@ skipping 18 matching lines @@
 StorageStorageAreaClearFunction::RunWithStorage(ValueStore* storage) {
   return UseWriteResult(storage->Clear(), storage);
 }
 
 void StorageStorageAreaClearFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 }  // namespace extensions