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

extensions/common/manifest_test.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/common/manifest_test.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/extension_paths.h"
 #include "extensions/common/test_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 namespace {
 
 // |manifest_path| is an absolute path to a manifest file.
 base::DictionaryValue* LoadManifestFile(const base::FilePath& manifest_path,
                                         std::string* error) {
   base::FilePath extension_path = manifest_path.DirName();
 
   EXPECT_TRUE(base::PathExists(manifest_path)) <<
       "Couldn't find " << manifest_path.value();
 
   JSONFileValueSerializer serializer(manifest_path);
-  base::DictionaryValue* manifest =
-      static_cast<base::DictionaryValue*>(serializer.Deserialize(NULL, error));
+  base::DictionaryValue* manifest = static_cast<base::DictionaryValue*>(
+      serializer.Deserialize(nullptr, error));
 
   // Most unit tests don't need localization, and they'll fail if we try to
   // localize them, since their manifests don't have a default_locale key.
   // Only localize manifests that indicate they want to be localized.
   // Calling LocalizeExtension at this point mirrors file_util::LoadExtension.
   if (manifest &&
       manifest_path.value().find(FILE_PATH_LITERAL("localized")) !=
       std::string::npos)
     extension_l10n_util::LocalizeExtension(extension_path, manifest, error);
 
   return manifest;
 }
 
 }  // namespace
 
 ManifestTest::ManifestTest()
     : enable_apps_(true) {
 }
 
 ManifestTest::~ManifestTest() {
 }
 
 // Helper class that simplifies creating methods that take either a filename
 // to a manifest or the manifest itself.
 ManifestTest::ManifestData::ManifestData(const char* name)
-    : name_(name), manifest_(NULL) {
+    : name_(name), manifest_(nullptr) {
 }
 
 ManifestTest::ManifestData::ManifestData(base::DictionaryValue* manifest,
                                           const char* name)
     : name_(name), manifest_(manifest) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
 ManifestTest::ManifestData::ManifestData(
     scoped_ptr<base::DictionaryValue> manifest)
@@ skipping 32 matching lines @@
 }
 
 scoped_refptr<Extension> ManifestTest::LoadExtension(
     const ManifestData& manifest,
     std::string* error,
     extensions::Manifest::Location location,
     int flags) {
   base::FilePath test_data_dir = GetTestDataDir();
   base::DictionaryValue* value = manifest.GetManifest(test_data_dir, error);
   if (!value)
-    return NULL;
+    return nullptr;
   return Extension::Create(
       test_data_dir.DirName(), location, *value, flags, error);
 }
 
 scoped_refptr<Extension> ManifestTest::LoadAndExpectSuccess(
     const ManifestData& manifest,
     extensions::Manifest::Location location,
     int flags) {
   std::string error;
   scoped_refptr<Extension> extension =
@@ skipping 128 matching lines @@
       break;
     case EXPECT_TYPE_SUCCESS:
       LoadAndExpectSuccess(testcase.manifest_filename_.c_str(),
                            testcase.location_,
                            testcase.flags_);
       break;
    }
 }
 
 }  // namespace extensions