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

extensions/common/extension.cc

 // Copyright (c) 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/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 96 matching lines @@
                                            const std::string& explicit_id,
                                            std::string* utf8_error) {
   DCHECK(utf8_error);
   base::string16 error;
   scoped_ptr<extensions::Manifest> manifest(
       new extensions::Manifest(
           location, scoped_ptr<base::DictionaryValue>(value.DeepCopy())));
 
   if (!InitExtensionID(manifest.get(), path, explicit_id, flags, &error)) {
     *utf8_error = base::UTF16ToUTF8(error);
-    return NULL;
+    return nullptr;
   }
 
   std::vector<InstallWarning> install_warnings;
   if (!manifest->ValidateManifest(utf8_error, &install_warnings)) {
-    return NULL;
+    return nullptr;
   }
 
   scoped_refptr<Extension> extension = new Extension(path, manifest.Pass());
   extension->install_warnings_.swap(install_warnings);
 
   if (!extension->InitFromValue(flags, &error)) {
     *utf8_error = base::UTF16ToUTF8(error);
-    return NULL;
+    return nullptr;
   }
 
   return extension;
 }
 
 Manifest::Type Extension::GetType() const {
   return converted_from_user_script() ?
       Manifest::TYPE_USER_SCRIPT : manifest_->type();
 }
 
@@ skipping 215 matching lines @@
 
   return false;
 }
 
 Extension::ManifestData* Extension::GetManifestData(const std::string& key)
     const {
   DCHECK(finished_parsing_manifest_ || thread_checker_.CalledOnValidThread());
   ManifestDataMap::const_iterator iter = manifest_data_.find(key);
   if (iter != manifest_data_.end())
     return iter->second.get();
-  return NULL;
+  return nullptr;
 }
 
 void Extension::SetManifestData(const std::string& key,
                                 Extension::ManifestData* data) {
   DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
   manifest_data_[key] = linked_ptr<ManifestData>(data);
 }
 
 Manifest::Location Extension::location() const {
   return manifest_->location();
@@ skipping 216 matching lines @@
     display_in_new_tab_page_ = display_in_launcher_;
   }
   return true;
 }
 
 bool Extension::LoadExtent(const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
                            base::string16* error) {
-  const base::Value* temp_pattern_value = NULL;
+  const base::Value* temp_pattern_value = nullptr;
   if (!manifest_->Get(key, &temp_pattern_value))
     return true;
 
-  const base::ListValue* pattern_list = NULL;
+  const base::ListValue* pattern_list = nullptr;
   if (!temp_pattern_value->GetAsList(&pattern_list)) {
     *error = base::ASCIIToUTF16(list_error);
     return false;
   }
 
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(value_error,
                                                    base::UintToString(i),
@@ skipping 145 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions