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

extensions/common/manifest_handlers/shared_module_info.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/common/manifest_handlers/shared_module_info.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 118 matching lines @@
   bool has_export = extension->manifest()->HasKey(keys::kExport);
   if (!has_import && !has_export)
     return true;
 
   if (has_import && has_export) {
     *error = base::ASCIIToUTF16(errors::kInvalidImportAndExport);
     return false;
   }
 
   if (has_export) {
-    const base::DictionaryValue* export_value = NULL;
+    const base::DictionaryValue* export_value = nullptr;
     if (!extension->manifest()->GetDictionary(keys::kExport, &export_value)) {
       *error = base::ASCIIToUTF16(errors::kInvalidExport);
       return false;
     }
-    const base::ListValue* resources_list = NULL;
+    const base::ListValue* resources_list = nullptr;
     if (!export_value->GetList(keys::kResources, &resources_list)) {
       *error = base::ASCIIToUTF16(errors::kInvalidExportResources);
       return false;
     }
     if (export_value->HasKey(keys::kWhitelist)) {
-      const base::ListValue* whitelist = NULL;
+      const base::ListValue* whitelist = nullptr;
       if (!export_value->GetList(keys::kWhitelist, &whitelist)) {
         *error = base::ASCIIToUTF16(errors::kInvalidExportWhitelist);
         return false;
       }
       for (size_t i = 0; i < whitelist->GetSize(); ++i) {
         std::string extension_id;
         if (!whitelist->GetString(i, &extension_id) ||
             !crx_file::id_util::IdIsValid(extension_id)) {
           *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidExportWhitelistString, base::IntToString(i));
@@ skipping 14 matching lines @@
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExportResourcesString, base::IntToString(i));
         return false;
       }
       exported_set_.AddPattern(
           URLPattern(URLPattern::SCHEME_EXTENSION, resolved_path.spec()));
     }
   }
 
   if (has_import) {
-    const base::ListValue* import_list = NULL;
+    const base::ListValue* import_list = nullptr;
     if (!extension->manifest()->GetList(keys::kImport, &import_list)) {
       *error = base::ASCIIToUTF16(errors::kInvalidImport);
       return false;
     }
     for (size_t i = 0; i < import_list->GetSize(); ++i) {
-      const base::DictionaryValue* import_entry = NULL;
+      const base::DictionaryValue* import_entry = nullptr;
       if (!import_list->GetDictionary(i, &import_entry)) {
         *error = base::ASCIIToUTF16(errors::kInvalidImport);
         return false;
       }
       std::string extension_id;
       imports_.push_back(ImportInfo());
       if (!import_entry->GetString(keys::kId, &extension_id) ||
           !crx_file::id_util::IdIsValid(extension_id)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidImportId, base::IntToString(i));
@@ skipping 52 matching lines @@
 
 const std::vector<std::string> SharedModuleHandler::Keys() const {
   static const char* keys[] = {
     keys::kExport,
     keys::kImport
   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions