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

extensions/browser/extension_prefs.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/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 193 matching lines @@
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, pref_names::kExtensions),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
   }
 
   // DictionaryPrefUpdate overrides:
   virtual base::DictionaryValue* Get() OVERRIDE {
     base::DictionaryValue* dict = DictionaryPrefUpdate::Get();
-    base::DictionaryValue* extension = NULL;
+    base::DictionaryValue* extension = nullptr;
     if (!dict->GetDictionary(extension_id_, &extension)) {
       // Extension pref does not exist, create it.
       extension = new base::DictionaryValue();
       dict->SetWithoutPathExpansion(extension_id_, extension);
     }
     return extension;
   }
 
  private:
   const std::string extension_id_;
@@ skipping 17 matching lines @@
                                   ExtensionPrefValueMap* value_map,
                                   const std::string& extension_id,
                                   ExtensionPrefsScope scope) {
   std::string scope_string;
   if (!pref_names::ScopeToPrefName(scope, &scope_string))
     return;
   std::string key = extension_id + "." + scope_string;
 
   const base::DictionaryValue* source_dict =
       prefs->pref_service()->GetDictionary(pref_names::kExtensions);
-  const base::DictionaryValue* preferences = NULL;
+  const base::DictionaryValue* preferences = nullptr;
   if (!source_dict->GetDictionary(key, &preferences))
     return;
 
   for (base::DictionaryValue::Iterator iter(*preferences); !iter.IsAtEnd();
        iter.Advance()) {
     value_map->SetExtensionPref(
         extension_id, iter.key(), scope, iter.value().DeepCopy());
   }
 }
 
@@ skipping 27 matching lines @@
   DCHECK(crx_file::id_util::IdIsValid(extension_id_));
 }
 
 template <typename T, base::Value::Type type_enum_value>
 ExtensionPrefs::ScopedUpdate<T, type_enum_value>::~ScopedUpdate() {
 }
 
 template <typename T, base::Value::Type type_enum_value>
 T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Get() {
   base::DictionaryValue* dict = update_.Get();
-  base::DictionaryValue* extension = NULL;
-  base::Value* key_value = NULL;
+  base::DictionaryValue* extension = nullptr;
+  base::Value* key_value = nullptr;
   if (!dict->GetDictionary(extension_id_, &extension) ||
       !extension->Get(key_, &key_value)) {
-    return NULL;
+    return nullptr;
   }
-  return key_value->GetType() == type_enum_value ?
-      static_cast<T*>(key_value) :
-      NULL;
+  return key_value->GetType() == type_enum_value ? static_cast<T*>(key_value)
+                                                 : nullptr;
 }
 
 template <typename T, base::Value::Type type_enum_value>
 T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Create() {
   base::DictionaryValue* dict = update_.Get();
-  base::DictionaryValue* extension = NULL;
-  base::Value* key_value = NULL;
-  T* value_as_t = NULL;
+  base::DictionaryValue* extension = nullptr;
+  base::Value* key_value = nullptr;
+  T* value_as_t = nullptr;
   if (!dict->GetDictionary(extension_id_, &extension)) {
     extension = new base::DictionaryValue;
     dict->SetWithoutPathExpansion(extension_id_, extension);
   }
   if (!extension->Get(key_, &key_value)) {
     value_as_t = new T;
     extension->SetWithoutPathExpansion(key_, value_as_t);
   } else {
     CHECK(key_value->GetType() == type_enum_value);
     value_as_t = static_cast<T*>(key_value);
@@ skipping 69 matching lines @@
 
 void ExtensionPrefs::MakePathsRelative() {
   const base::DictionaryValue* dict =
       prefs_->GetDictionary(pref_names::kExtensions);
   if (!dict || dict->empty())
     return;
 
   // Collect all extensions ids with absolute paths in |absolute_keys|.
   std::set<std::string> absolute_keys;
   for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
-    const base::DictionaryValue* extension_dict = NULL;
+    const base::DictionaryValue* extension_dict = nullptr;
     if (!i.value().GetAsDictionary(&extension_dict))
       continue;
     int location_value;
     if (extension_dict->GetInteger(kPrefLocation, &location_value) &&
         Manifest::IsUnpackedLocation(
             static_cast<Manifest::Location>(location_value))) {
       // Unpacked extensions can have absolute paths.
       continue;
     }
     base::FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     base::FilePath path(path_string);
     if (path.IsAbsolute())
       absolute_keys.insert(i.key());
   }
   if (absolute_keys.empty())
     return;
 
   // Fix these paths.
   DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
   base::DictionaryValue* update_dict = update.Get();
   for (std::set<std::string>::iterator i = absolute_keys.begin();
        i != absolute_keys.end(); ++i) {
-    base::DictionaryValue* extension_dict = NULL;
+    base::DictionaryValue* extension_dict = nullptr;
     if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
       NOTREACHED() << "Control should never reach here for extension " << *i;
       continue;
     }
     base::FilePath::StringType path_string;
     extension_dict->GetString(kPrefPath, &path_string);
     base::FilePath path(path_string);
     extension_dict->SetString(kPrefPath,
         MakePathRelative(install_directory_, path));
   }
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
-  const base::DictionaryValue* extension_dict = NULL;
+  const base::DictionaryValue* extension_dict = nullptr;
   if (!extensions ||
       !extensions->GetDictionary(extension_id, &extension_dict)) {
-    return NULL;
+    return nullptr;
   }
   return extension_dict;
 }
 
 void ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
                                          const std::string& key,
                                          base::Value* data_value) {
   if (!crx_file::id_util::IdIsValid(extension_id)) {
     NOTREACHED() << "Invalid extension_id " << extension_id;
     return;
   }
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   if (data_value)
     update->Set(key, data_value);
   else
-    update->Remove(key, NULL);
+    update->Remove(key, nullptr);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   extension_pref_value_map_->UnregisterExtension(extension_id);
   FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                     observer_list_,
                     OnExtensionPrefsDeleted(extension_id));
   DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
   base::DictionaryValue* dict = update.Get();
-  dict->Remove(extension_id, NULL);
+  dict->Remove(extension_id, nullptr);
 }
 
 bool ExtensionPrefs::ReadPrefAsBoolean(const std::string& extension_id,
                                        const std::string& pref_key,
                                        bool* out_value) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
   if (!ext || !ext->GetBoolean(pref_key, out_value))
     return false;
 
   return true;
@@ skipping 16 matching lines @@
   if (!ext || !ext->GetString(pref_key, out_value))
     return false;
 
   return true;
 }
 
 bool ExtensionPrefs::ReadPrefAsList(const std::string& extension_id,
                                     const std::string& pref_key,
                                     const base::ListValue** out_value) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
-  const base::ListValue* out = NULL;
+  const base::ListValue* out = nullptr;
   if (!ext || !ext->GetList(pref_key, &out))
     return false;
   if (out_value)
     *out_value = out;
 
   return true;
 }
 
 bool ExtensionPrefs::ReadPrefAsDictionary(
     const std::string& extension_id,
     const std::string& pref_key,
     const base::DictionaryValue** out_value) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
-  const base::DictionaryValue* out = NULL;
+  const base::DictionaryValue* out = nullptr;
   if (!ext || !ext->GetDictionary(pref_key, &out))
     return false;
   if (out_value)
     *out_value = out;
 
   return true;
 }
 
 bool ExtensionPrefs::HasPrefForExtension(
     const std::string& extension_id) const {
-  return GetExtensionPref(extension_id) != NULL;
+  return GetExtensionPref(extension_id) != nullptr;
 }
 
 bool ExtensionPrefs::ReadPrefAsURLPatternSet(const std::string& extension_id,
                                              const std::string& pref_key,
                                              URLPatternSet* result,
                                              int valid_schemes) {
-  const base::ListValue* value = NULL;
+  const base::ListValue* value = nullptr;
   if (!ReadPrefAsList(extension_id, pref_key, &value))
     return false;
 
   bool allow_file_access = AllowFileAccess(extension_id);
-  return result->Populate(*value, valid_schemes, allow_file_access, NULL);
+  return result->Populate(*value, valid_schemes, allow_file_access, nullptr);
 }
 
 void ExtensionPrefs::SetExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
     const URLPatternSet& new_value) {
   UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release());
 }
 
 bool ExtensionPrefs::ReadPrefAsBooleanAndReturn(
     const std::string& extension_id,
     const std::string& pref_key) const {
   bool out_value = false;
   return ReadPrefAsBoolean(extension_id, pref_key, &out_value) && out_value;
 }
 
 PermissionSet* ExtensionPrefs::ReadPrefAsPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key) {
   if (!GetExtensionPref(extension_id))
-    return NULL;
+    return nullptr;
 
   // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet()
   // for api_values format.
   APIPermissionSet apis;
-  const base::ListValue* api_values = NULL;
+  const base::ListValue* api_values = nullptr;
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   if (ReadPrefAsList(extension_id, api_pref, &api_values)) {
     APIPermissionSet::ParseFromJSON(api_values,
                                     APIPermissionSet::kAllowInternalPermissions,
-                                    &apis, NULL, NULL);
+                                    &apis,
+                                    nullptr,
+                                    nullptr);
   }
 
   // Retrieve the Manifest Keys permissions. Please refer to
   // |SetExtensionPrefPermissionSet| for manifest_permissions_values format.
   ManifestPermissionSet manifest_permissions;
-  const base::ListValue* manifest_permissions_values = NULL;
+  const base::ListValue* manifest_permissions_values = nullptr;
   std::string manifest_permission_pref =
       JoinPrefs(pref_key, kPrefManifestPermissions);
   if (ReadPrefAsList(extension_id, manifest_permission_pref,
                      &manifest_permissions_values)) {
     ManifestPermissionSet::ParseFromJSON(
-        manifest_permissions_values, &manifest_permissions, NULL, NULL);
+        manifest_permissions_values, &manifest_permissions, nullptr, nullptr);
   }
 
   // Retrieve the explicit host permissions.
   URLPatternSet explicit_hosts;
   ReadPrefAsURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
       &explicit_hosts, Extension::kValidHostPermissionSchemes);
 
   // Retrieve the scriptable host permissions.
   URLPatternSet scriptable_hosts;
@@ skipping 74 matching lines @@
 bool ExtensionPrefs::IsExternalExtensionAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeExternalExtension(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalAcknowledged,
                       new base::FundamentalValue(true));
-  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
+  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, nullptr);
 }
 
 bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefBlacklistAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeBlacklistedExtension(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged,
                       new base::FundamentalValue(true));
-  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
+  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, nullptr);
 }
 
 bool ExtensionPrefs::IsExternalInstallFirstRun(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalInstallFirstRun);
 }
 
 void ExtensionPrefs::SetExternalInstallFirstRun(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalInstallFirstRun,
                       new base::FundamentalValue(true));
 }
 
 bool ExtensionPrefs::HasWipeoutBeenAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefWipeoutAcknowledged);
 }
 
 void ExtensionPrefs::SetWipeoutAcknowledged(
     const std::string& extension_id,
     bool value) {
   UpdateExtensionPref(extension_id,
                       kPrefWipeoutAcknowledged,
-                      value ? new base::FundamentalValue(value) : NULL);
+                      value ? new base::FundamentalValue(value) : nullptr);
 }
 
 bool ExtensionPrefs::HasSettingsApiBubbleBeenAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id,
                                     kPrefSettingsBubbleAcknowledged);
 }
 
 void ExtensionPrefs::SetSettingsApiBubbleBeenAcknowledged(
     const std::string& extension_id,
     bool value) {
   UpdateExtensionPref(extension_id,
                       kPrefSettingsBubbleAcknowledged,
-                      value ? new base::FundamentalValue(value) : NULL);
+                      value ? new base::FundamentalValue(value) : nullptr);
 }
 
 bool ExtensionPrefs::HasNtpOverriddenBubbleBeenAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefNtpBubbleAcknowledged);
 }
 
 void ExtensionPrefs::SetNtpOverriddenBubbleBeenAcknowledged(
     const std::string& extension_id,
     bool value) {
   UpdateExtensionPref(extension_id,
                       kPrefNtpBubbleAcknowledged,
-                      value ? new base::FundamentalValue(value) : NULL);
+                      value ? new base::FundamentalValue(value) : nullptr);
 }
 
 bool ExtensionPrefs::HasProxyOverriddenBubbleBeenAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefProxyBubbleAcknowledged);
 }
 
 void ExtensionPrefs::SetProxyOverriddenBubbleBeenAcknowledged(
     const std::string& extension_id,
     bool value) {
   UpdateExtensionPref(extension_id,
                       kPrefProxyBubbleAcknowledged,
-                      value ? new base::FundamentalValue(value) : NULL);
+                      value ? new base::FundamentalValue(value) : nullptr);
 }
 
 bool ExtensionPrefs::SetAlertSystemFirstRun() {
   if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) {
     return true;
   }
   prefs_->SetBoolean(pref_names::kAlertsInitialized, true);
   return false;
 }
 
@@ skipping 54 matching lines @@
       break;
     case DISABLE_REASON_CLEAR:
       new_value = Extension::DISABLE_NONE;
       break;
   }
 
   if (old_value == new_value)  // no change, return.
     return;
 
   if (new_value == Extension::DISABLE_NONE) {
-    UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
+    UpdateExtensionPref(extension_id, kPrefDisableReasons, nullptr);
   } else {
     UpdateExtensionPref(extension_id,
                         kPrefDisableReasons,
                         new base::FundamentalValue(new_value));
   }
 
   FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                     observer_list_,
                     OnExtensionDisableReasonsChanged(extension_id, new_value));
 }
@@ skipping 22 matching lines @@
 }
 
 void ExtensionPrefs::SetExtensionBlacklisted(const std::string& extension_id,
                                              bool is_blacklisted) {
   bool currently_blacklisted = IsExtensionBlacklisted(extension_id);
   if (is_blacklisted == currently_blacklisted)
     return;
 
   // Always make sure the "acknowledged" bit is cleared since the blacklist bit
   // is changing.
-  UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, NULL);
+  UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, nullptr);
 
   if (is_blacklisted) {
     UpdateExtensionPref(extension_id,
                         kPrefBlacklist,
                         new base::FundamentalValue(true));
   } else {
-    UpdateExtensionPref(extension_id, kPrefBlacklist, NULL);
+    UpdateExtensionPref(extension_id, kPrefBlacklist, nullptr);
     const base::DictionaryValue* dict = GetExtensionPref(extension_id);
     if (dict && dict->empty())
       DeleteExtensionPrefs(extension_id);
   }
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const {
   const base::DictionaryValue* ext_prefs = GetExtensionPref(id);
   return ext_prefs && IsBlacklistBitSet(ext_prefs);
 }
@@ skipping 103 matching lines @@
     const base::DictionaryValue* ext = GetExtensionPref(*ext_id);
     if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access))
       continue;
 
     // Remove the full access bit (empty list will get trimmed).
     UpdateExtensionPref(
         *ext_id, kPrefOldGrantedFullAccess, new base::ListValue());
 
     // Add the plugin permission if the full access bit was set.
     if (full_access) {
-      const base::ListValue* apis = NULL;
-      base::ListValue* new_apis = NULL;
+      const base::ListValue* apis = nullptr;
+      base::ListValue* new_apis = nullptr;
 
       std::string granted_apis = JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
       if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new base::ListValue();
 
       std::string plugin_name = info->GetByID(APIPermission::kPlugin)->name();
       new_apis->Append(new base::StringValue(plugin_name));
       UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
     // which are a combination of host and user script host permissions.
     // We now maintain these lists separately. For migration purposes, it
     // does not matter how we treat the old effective hosts as long as the
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
-    const base::ListValue* hosts = NULL;
+    const base::ListValue* hosts = nullptr;
     std::string explicit_hosts =
         JoinPrefs(kPrefGrantedPermissions, kPrefExplicitHosts);
     if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
       UpdateExtensionPref(
           *ext_id, explicit_hosts, hosts->DeepCopy());
 
       // We can get rid of the old one by setting it to an empty list.
       UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new base::ListValue());
     }
   }
@@ skipping 14 matching lines @@
           new_value = Extension::DISABLE_PERMISSIONS_INCREASE;
           break;
         case Extension::DEPRECATED_DISABLE_RELOAD:
           new_value = Extension::DISABLE_RELOAD;
           break;
       }
 
       UpdateExtensionPref(*ext_id, kPrefDisableReasons,
                           new base::FundamentalValue(new_value));
       // Remove the old disable reason.
-      UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, NULL);
+      UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, nullptr);
     }
   }
 }
 
 PermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
@@ skipping 225 matching lines @@
 
   return version;
 }
 
 void ExtensionPrefs::UpdateManifest(const Extension* extension) {
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     const base::DictionaryValue* extension_dict =
         GetExtensionPref(extension->id());
     if (!extension_dict)
       return;
-    const base::DictionaryValue* old_manifest = NULL;
+    const base::DictionaryValue* old_manifest = nullptr;
     bool update_required =
         !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
         !extension->manifest()->value()->Equals(old_manifest);
     if (update_required) {
       UpdateExtensionPref(extension->id(), kPrefManifest,
                           extension->manifest()->value()->DeepCopy());
     }
   }
 }
 
@@ skipping 15 matching lines @@
   }
 
   // Only the following extension types have data saved in the preferences.
   if (location != Manifest::INTERNAL &&
       !Manifest::IsUnpackedLocation(location) &&
       !Manifest::IsExternalLocation(location)) {
     NOTREACHED();
     return scoped_ptr<ExtensionInfo>();
   }
 
-  const base::DictionaryValue* manifest = NULL;
+  const base::DictionaryValue* manifest = nullptr;
   if (!Manifest::IsUnpackedLocation(location) &&
       !extension->GetDictionary(kPrefManifest, &manifest)) {
     LOG(WARNING) << "Missing manifest for extension " << extension_id;
     // Just a warning for now.
   }
 
   base::FilePath::StringType path;
   if (!extension->GetString(kPrefPath, &path))
     return scoped_ptr<ExtensionInfo>();
 
   // Make path absolute. Most (but not all) extension types have relative paths.
   if (!base::FilePath(path).IsAbsolute())
     path = install_directory_.Append(path).value();
 
   return scoped_ptr<ExtensionInfo>(new ExtensionInfo(
       manifest, extension_id, base::FilePath(path), location));
 }
 
 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
     const std::string& extension_id) const {
-  const base::DictionaryValue* ext = NULL;
+  const base::DictionaryValue* ext = nullptr;
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   if (!extensions ||
       !extensions->GetDictionaryWithoutPathExpansion(extension_id, &ext))
     return scoped_ptr<ExtensionInfo>();
   int state_value;
   if (ext->GetInteger(kPrefState, &state_value) &&
       state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) {
     LOG(WARNING) << "External extension with id " << extension_id
                  << " has been uninstalled by the user";
@@ skipping 24 matching lines @@
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetUninstalledExtensionsInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
-    const base::DictionaryValue* ext = NULL;
+    const base::DictionaryValue* ext = nullptr;
     if (!crx_file::id_util::IdIsValid(extension_id.key()) ||
         !IsExternalExtensionUninstalled(extension_id.key()) ||
         !extension_id.value().GetAsDictionary(&ext))
       continue;
 
     scoped_ptr<ExtensionInfo> info =
         GetInstalledInfoHelper(extension_id.key(), ext);
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
@@ skipping 30 matching lines @@
                              static_cast<int>(delay_reason));
 
   UpdateExtensionPref(extension->id(), kDelayedInstallInfo, extension_dict);
 }
 
 bool ExtensionPrefs::RemoveDelayedInstallInfo(
     const std::string& extension_id) {
   if (!GetExtensionPref(extension_id))
     return false;
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
-  bool result = update->Remove(kDelayedInstallInfo, NULL);
+  bool result = update->Remove(kDelayedInstallInfo, nullptr);
   return result;
 }
 
 bool ExtensionPrefs::FinishDelayedInstallInfo(
     const std::string& extension_id) {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   base::DictionaryValue* extension_dict = update.Get();
-  base::DictionaryValue* pending_install_dict = NULL;
+  base::DictionaryValue* pending_install_dict = nullptr;
   if (!extension_dict->GetDictionary(kDelayedInstallInfo,
                                      &pending_install_dict)) {
     return false;
   }
 
   // Retrieve and clear transient values populated by SetDelayedInstallInfo().
   // Also do any other data cleanup that makes sense.
   std::string serialized_ordinal;
   syncer::StringOrdinal suggested_page_ordinal;
   bool needs_sort_ordinal = false;
   if (pending_install_dict->GetString(kPrefSuggestedPageOrdinal,
                                       &serialized_ordinal)) {
     suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal);
     needs_sort_ordinal = true;
-    pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL);
+    pending_install_dict->Remove(kPrefSuggestedPageOrdinal, nullptr);
   }
-  pending_install_dict->Remove(kDelayedInstallReason, NULL);
+  pending_install_dict->Remove(kDelayedInstallReason, nullptr);
 
   const base::Time install_time = time_provider_->GetCurrentTime();
   pending_install_dict->Set(
       kPrefInstallTime,
       new base::StringValue(
           base::Int64ToString(install_time.ToInternalValue())));
 
   // Some extension pref values are written conditionally. If they are not
   // present in the delayed install data, they should be removed when the
   // delayed install is committed.
-  extension_dict->Remove(kPrefEphemeralApp, NULL);
+  extension_dict->Remove(kPrefEphemeralApp, nullptr);
 
   // Commit the delayed install data.
   for (base::DictionaryValue::Iterator it(*pending_install_dict); !it.IsAtEnd();
        it.Advance()) {
     extension_dict->Set(it.key(), it.value().DeepCopy());
   }
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict);
   return true;
 }
 
 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs =
       GetExtensionPref(extension_id);
   if (!extension_prefs)
     return scoped_ptr<ExtensionInfo>();
 
-  const base::DictionaryValue* ext = NULL;
+  const base::DictionaryValue* ext = nullptr;
   if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
     return scoped_ptr<ExtensionInfo>();
 
   return GetInstalledInfoHelper(extension_id, ext);
 }
 
 ExtensionPrefs::DelayReason ExtensionPrefs::GetDelayedInstallReason(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs =
       GetExtensionPref(extension_id);
   if (!extension_prefs)
     return DELAY_REASON_NONE;
 
-  const base::DictionaryValue* ext = NULL;
+  const base::DictionaryValue* ext = nullptr;
   if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
     return DELAY_REASON_NONE;
 
   int delay_reason;
   if (!ext->GetInteger(kDelayedInstallReason, &delay_reason))
     return DELAY_REASON_NONE;
 
   return static_cast<DelayReason>(delay_reason);
 }
 
@@ skipping 21 matching lines @@
     return true;
 
   // Ephemerality was previously stored in the creation flags, so we must also
   // check it for backcompatibility.
   return (GetCreationFlags(extension_id) & Extension::IS_EPHEMERAL) != 0;
 }
 
 void ExtensionPrefs::OnEphemeralAppPromoted(const std::string& extension_id) {
   DCHECK(IsEphemeralApp(extension_id));
 
-  UpdateExtensionPref(extension_id, kPrefEphemeralApp, NULL);
+  UpdateExtensionPref(extension_id, kPrefEphemeralApp, nullptr);
 
   // Ephemerality was previously stored in the creation flags, so ensure the bit
   // is cleared.
   int creation_flags = Extension::NO_FLAGS;
   if (ReadPrefAsInteger(extension_id, kPrefCreationFlags, &creation_flags)) {
     if (creation_flags & Extension::IS_EPHEMERAL) {
       creation_flags &= ~static_cast<int>(Extension::IS_EPHEMERAL);
       UpdateExtensionPref(extension_id,
                           kPrefCreationFlags,
                           new base::FundamentalValue(creation_flags));
@@ skipping 41 matching lines @@
       creation_flags |= Extension::WAS_INSTALLED_BY_DEFAULT;
     if (WasInstalledByOem(extension_id))
       creation_flags |= Extension::WAS_INSTALLED_BY_OEM;
   }
   return creation_flags;
 }
 
 int ExtensionPrefs::GetDelayedInstallCreationFlags(
     const std::string& extension_id) const {
   int creation_flags = Extension::NO_FLAGS;
-  const base::DictionaryValue* delayed_info = NULL;
+  const base::DictionaryValue* delayed_info = nullptr;
   if (ReadPrefAsDictionary(extension_id, kDelayedInstallInfo, &delayed_info)) {
     delayed_info->GetInteger(kPrefCreationFlags, &creation_flags);
   }
   return creation_flags;
 }
 
 bool ExtensionPrefs::WasInstalledByDefault(
     const std::string& extension_id) const {
   const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
@@ skipping 66 matching lines @@
     ExtensionInfo* info = extensions_info->at(i).get();
     out->push_back(info->extension_id);
   }
 }
 
 // static
 ExtensionIdList ExtensionPrefs::GetExtensionsFrom(
     const PrefService* pref_service) {
   ExtensionIdList result;
 
-  const base::DictionaryValue* extension_prefs = NULL;
+  const base::DictionaryValue* extension_prefs = nullptr;
   const base::Value* extension_prefs_value =
       pref_service->GetUserPrefValue(pref_names::kExtensions);
   if (!extension_prefs_value ||
       !extension_prefs_value->GetAsDictionary(&extension_prefs)) {
     return result;  // Empty set
   }
 
   for (base::DictionaryValue::Iterator it(*extension_prefs); !it.IsAtEnd();
        it.Advance()) {
-    const base::DictionaryValue* ext = NULL;
+    const base::DictionaryValue* ext = nullptr;
     if (!it.value().GetAsDictionary(&ext)) {
       NOTREACHED() << "Invalid pref for extension " << it.key();
       continue;
     }
     if (!IsBlacklistBitSet(ext))
       result.push_back(it.key());
   }
   return result;
 }
 
@@ skipping 58 matching lines @@
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetGeometryCache(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
-    return NULL;
+    return nullptr;
 
-  const base::DictionaryValue* ext = NULL;
+  const base::DictionaryValue* ext = nullptr;
   if (!extension_prefs->GetDictionary(kPrefGeometryCache, &ext))
-    return NULL;
+    return nullptr;
 
   return ext;
 }
 
 void ExtensionPrefs::SetGeometryCache(
     const std::string& extension_id,
     scoped_ptr<base::DictionaryValue> cache) {
   UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
 }
 
@@ skipping 203 matching lines @@
       new base::FundamentalValue(extension->was_installed_by_oem()));
   extension_dict->Set(kPrefInstallTime,
                       new base::StringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
   if (install_flags & kInstallFlagIsBlacklistedForMalware)
     extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true));
 
   if (install_flags & kInstallFlagIsEphemeral)
     extension_dict->Set(kPrefEphemeralApp, new base::FundamentalValue(true));
   else
-    extension_dict->Remove(kPrefEphemeralApp, NULL);
+    extension_dict->Remove(kPrefEphemeralApp, nullptr);
 
   base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                      extension->path());
   extension_dict->Set(kPrefPath, new base::StringValue(path));
   if (!install_parameter.empty()) {
     extension_dict->Set(kPrefInstallParam,
                         new base::StringValue(install_parameter));
   }
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest()->value()->DeepCopy());
   }
 
   // Only writes kPrefDoNotSync when it is not the default.
   if (install_flags & kInstallFlagDoNotSync)
     extension_dict->Set(kPrefDoNotSync, new base::FundamentalValue(true));
   else
-    extension_dict->Remove(kPrefDoNotSync, NULL);
+    extension_dict->Remove(kPrefDoNotSync, nullptr);
 }
 
 void ExtensionPrefs::InitExtensionControlledPrefs(
     ExtensionPrefValueMap* value_map) {
   ExtensionIdList extension_ids;
   GetExtensions(&extension_ids);
 
   for (ExtensionIdList::iterator extension_id = extension_ids.begin();
        extension_id != extension_ids.end();
        ++extension_id) {
@@ skipping 51 matching lines @@
   if (!extension_dict->HasKey(pref_names::kPrefContentSettings))
     extension_dict->Set(pref_names::kPrefContentSettings, new base::ListValue);
 
   if (!extension_dict->HasKey(pref_names::kPrefIncognitoContentSettings)) {
     extension_dict->Set(pref_names::kPrefIncognitoContentSettings,
                         new base::ListValue);
   }
 
   // If this point has been reached, any pending installs should be considered
   // out of date.
-  extension_dict->Remove(kDelayedInstallInfo, NULL);
+  extension_dict->Remove(kDelayedInstallInfo, nullptr);
 
   // Clear state that may be registered from a previous install.
-  extension_dict->Remove(EventRouter::kRegisteredEvents, NULL);
+  extension_dict->Remove(EventRouter::kRegisteredEvents, nullptr);
 
   // FYI, all code below here races on sudden shutdown because |extension_dict|,
   // |app_sorting_|, |extension_pref_value_map_|, and (potentially) observers
   // are updated non-transactionally. This is probably not fixable without
   // nested transactional updates to pref dictionaries.
   if (needs_sort_ordinal)
     app_sorting_->EnsureValidOrdinals(extension_id, suggested_page_ordinal);
 
   bool is_enabled = false;
   int initial_state;
   if (extension_dict->GetInteger(kPrefState, &initial_state)) {
     is_enabled = initial_state == Extension::ENABLED;
   }
   bool is_incognito_enabled = IsIncognitoEnabled(extension_id);
 
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions