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

extensions/common/extension_l10n_util.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/common/extension_l10n_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 
 // Loads contents of the messages file for given locale. If file is not found,
 // or there was parsing error we return NULL and set |error|.
 // Caller owns the returned object.
 base::DictionaryValue* LoadMessageFile(const base::FilePath& locale_path,
                                        const std::string& locale,
                                        std::string* error) {
   base::FilePath file =
       locale_path.AppendASCII(locale).Append(extensions::kMessagesFilename);
   JSONFileValueSerializer messages_serializer(file);
-  base::Value* dictionary = messages_serializer.Deserialize(NULL, error);
+  base::Value* dictionary = messages_serializer.Deserialize(nullptr, error);
   if (!dictionary) {
     if (error->empty()) {
       // JSONFileValueSerializer just returns NULL if file cannot be found. It
       // doesn't set the error, so we have to do it.
       *error = base::StringPrintf("Catalog file is missing for locale %s.",
                                   locale.c_str());
     } else {
       *error = extensions::ErrorUtils::FormatErrorMessage(
           errors::kLocalesInvalidLocale,
           base::UTF16ToUTF8(file.LossyDisplayName()),
@@ skipping 18 matching lines @@
 
   manifest->SetString(key, result);
   return true;
 }
 
 // Localizes manifest value of list type for a given key.
 bool LocalizeManifestListValue(const std::string& key,
                                const extensions::MessageBundle& messages,
                                base::DictionaryValue* manifest,
                                std::string* error) {
-  base::ListValue* list = NULL;
+  base::ListValue* list = nullptr;
   if (!manifest->GetList(key, &list))
     return true;
 
   bool ret = true;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string result;
     if (list->GetString(i, &result)) {
       if (messages.ReplaceMessages(&result, error))
         list->Set(i, new base::StringValue(result));
       else
@@ skipping 70 matching lines @@
   key.assign(keys::kPageAction);
   key.append(".");
   key.append(keys::kPageActionDefaultTitle);
   if (!LocalizeManifestValue(key, messages, manifest, error))
     return false;
 
   // Initialize omnibox.keyword.
   if (!LocalizeManifestValue(keys::kOmniboxKeyword, messages, manifest, error))
     return false;
 
-  base::ListValue* file_handlers = NULL;
+  base::ListValue* file_handlers = nullptr;
   if (manifest->GetList(keys::kFileBrowserHandlers, &file_handlers)) {
     key.assign(keys::kFileBrowserHandlers);
     for (size_t i = 0; i < file_handlers->GetSize(); i++) {
-      base::DictionaryValue* handler = NULL;
+      base::DictionaryValue* handler = nullptr;
       if (!file_handlers->GetDictionary(i, &handler)) {
         *error = errors::kInvalidFileBrowserHandler;
         return false;
       }
       if (!LocalizeManifestValue(
               keys::kPageActionDefaultTitle, messages, handler, error))
         return false;
     }
   }
 
   // Initialize all input_components
-  base::ListValue* input_components = NULL;
+  base::ListValue* input_components = nullptr;
   if (manifest->GetList(keys::kInputComponents, &input_components)) {
     for (size_t i = 0; i < input_components->GetSize(); ++i) {
-      base::DictionaryValue* module = NULL;
+      base::DictionaryValue* module = nullptr;
       if (!input_components->GetDictionary(i, &module)) {
         *error = errors::kInvalidInputComponents;
         return false;
       }
       if (!LocalizeManifestValue(keys::kName, messages, module, error))
         return false;
       if (!LocalizeManifestValue(keys::kDescription, messages, module, error))
         return false;
     }
   }
 
   // Initialize app.launch.local_path.
   if (!LocalizeManifestValue(keys::kLaunchLocalPath, messages, manifest, error))
     return false;
 
   // Initialize app.launch.web_url.
   if (!LocalizeManifestValue(keys::kLaunchWebURL, messages, manifest, error))
     return false;
 
   // Initialize description of commmands.
-  base::DictionaryValue* commands_handler = NULL;
+  base::DictionaryValue* commands_handler = nullptr;
   if (manifest->GetDictionary(keys::kCommands, &commands_handler)) {
     for (base::DictionaryValue::Iterator iter(*commands_handler);
          !iter.IsAtEnd();
          iter.Advance()) {
       key.assign(
           base::StringPrintf("commands.%s.description", iter.key().c_str()));
       if (!LocalizeManifestValue(key, messages, manifest, error))
         return false;
     }
   }
 
   // Initialize search_provider fields.
-  base::DictionaryValue* search_provider = NULL;
+  base::DictionaryValue* search_provider = nullptr;
   if (manifest->GetDictionary(keys::kOverrideSearchProvider,
                               &search_provider)) {
     for (base::DictionaryValue::Iterator iter(*search_provider);
          !iter.IsAtEnd();
          iter.Advance()) {
       key.assign(base::StringPrintf(
           "%s.%s", keys::kOverrideSearchProvider, iter.key().c_str()));
       bool success =
           (key == keys::kSettingsOverrideAlternateUrls)
               ? LocalizeManifestListValue(key, messages, manifest, error)
@@ skipping 140 matching lines @@
   std::vector<linked_ptr<base::DictionaryValue> > catalogs;
   for (size_t i = 0; i < all_fallback_locales.size(); ++i) {
     // Skip all parent locales that are not supplied.
     if (valid_locales.find(all_fallback_locales[i]) == valid_locales.end())
       continue;
     linked_ptr<base::DictionaryValue> catalog(
         LoadMessageFile(locale_path, all_fallback_locales[i], error));
     if (!catalog.get()) {
       // If locale is valid, but messages.json is corrupted or missing, return
       // an error.
-      return NULL;
+      return nullptr;
     } else {
       catalogs.push_back(catalog);
     }
   }
 
   return extensions::MessageBundle::Create(catalogs, error);
 }
 
 bool ValidateExtensionLocales(const base::FilePath& extension_path,
                               const base::DictionaryValue* manifest,
@@ skipping 56 matching lines @@
 ScopedLocaleForTest::ScopedLocaleForTest(const std::string& locale)
     : locale_(extension_l10n_util::CurrentLocaleOrDefault()) {
   extension_l10n_util::SetProcessLocale(locale);
 }
 
 ScopedLocaleForTest::~ScopedLocaleForTest() {
   extension_l10n_util::SetProcessLocale(locale_);
 }
 
 }  // namespace extension_l10n_util