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

extensions/browser/extension_pref_value_map.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_pref_value_map.h"
 
 #include "base/prefs/pref_value_map.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 
@@ skipping 62 matching lines @@
   ExtensionEntryMap::const_iterator ext = entries_.find(extension_id);
   if (ext == entries_.end()) {
     NOTREACHED();
     return false;
   }
 
   if (incognito && !ext->second->incognito_enabled)
     return false;
 
   ExtensionEntryMap::const_iterator winner =
-      GetEffectivePrefValueController(pref_key, incognito, NULL);
+      GetEffectivePrefValueController(pref_key, incognito, nullptr);
   if (winner == entries_.end())
     return true;
 
   return winner->second->install_time <= ext->second->install_time;
 }
 
 void ExtensionPrefValueMap::ClearAllIncognitoSessionOnlyPreferences() {
   typedef std::set<std::string> KeySet;
   KeySet deleted_keys;
 
   ExtensionEntryMap::iterator i;
   for (i = entries_.begin(); i != entries_.end(); ++i) {
     PrefValueMap& inc_prefs =
         i->second->incognito_profile_preferences_session_only;
     PrefValueMap::iterator j;
     for (j = inc_prefs.begin(); j != inc_prefs.end(); ++j)
       deleted_keys.insert(j->first);
     inc_prefs.Clear();
   }
 
   KeySet::iterator k;
   for (k = deleted_keys.begin(); k != deleted_keys.end(); ++k)
     NotifyPrefValueChanged(*k);
 }
 
 bool ExtensionPrefValueMap::DoesExtensionControlPref(
     const std::string& extension_id,
     const std::string& pref_key,
     bool* from_incognito) const {
-  bool incognito = (from_incognito != NULL);
+  bool incognito = (from_incognito != nullptr);
   ExtensionEntryMap::const_iterator winner =
       GetEffectivePrefValueController(pref_key, incognito, from_incognito);
   if (winner == entries_.end())
     return false;
   return winner->first == extension_id;
 }
 
 void ExtensionPrefValueMap::RegisterExtension(const std::string& ext_id,
                                               const base::Time& install_time,
                                               bool is_enabled,
@@ skipping 62 matching lines @@
     case extensions::kExtensionPrefsScopeRegular:
       return &(i->second->regular_profile_preferences);
     case extensions::kExtensionPrefsScopeRegularOnly:
       return &(i->second->regular_only_profile_preferences);
     case extensions::kExtensionPrefsScopeIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
     case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
       return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
     const std::string& ext_id,
     ExtensionPrefsScope scope) const {
   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
   CHECK(i != entries_.end());
   switch (scope) {
     case extensions::kExtensionPrefsScopeRegular:
       return &(i->second->regular_profile_preferences);
     case extensions::kExtensionPrefsScopeRegularOnly:
       return &(i->second->regular_only_profile_preferences);
     case extensions::kExtensionPrefsScopeIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
     case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
       return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 void ExtensionPrefValueMap::GetExtensionControlledKeys(
     const ExtensionEntry& entry,
     std::set<std::string>* out) const {
   PrefValueMap::const_iterator i;
 
   const PrefValueMap& regular_prefs = entry.regular_profile_preferences;
   for (i = regular_prefs.begin(); i != regular_prefs.end(); ++i)
     out->insert(i->first);
@@ skipping 14 matching lines @@
     out->insert(i->first);
 }
 
 const base::Value* ExtensionPrefValueMap::GetEffectivePrefValue(
     const std::string& key,
     bool incognito,
     bool* from_incognito) const {
   ExtensionEntryMap::const_iterator winner =
       GetEffectivePrefValueController(key, incognito, from_incognito);
   if (winner == entries_.end())
-    return NULL;
+    return nullptr;
 
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   const std::string& ext_id = winner->first;
 
   // First search for incognito session only preferences.
   if (incognito) {
     DCHECK(winner->second->incognito_enabled);
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
         ext_id, extensions::kExtensionPrefsScopeIncognitoSessionOnly);
     prefs->GetValue(key, &value);
     if (value)
       return value;
@@ skipping 37 matching lines @@
     const bool enabled = i->second->enabled;
     const bool incognito_enabled = i->second->incognito_enabled;
 
     if (!enabled)
       continue;
     if (install_time < winners_install_time)
       continue;
     if (incognito && !incognito_enabled)
       continue;
 
-    const base::Value* value = NULL;
+    const base::Value* value = nullptr;
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
         ext_id, extensions::kExtensionPrefsScopeRegular);
     if (prefs->GetValue(key, &value)) {
       winner = i;
       winners_install_time = install_time;
       if (from_incognito)
         *from_incognito = false;
     }
 
     if (!incognito) {
@@ skipping 46 matching lines @@
 }
 
 void ExtensionPrefValueMap::RemoveObserver(
     ExtensionPrefValueMap::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::string ExtensionPrefValueMap::GetExtensionControllingPref(
     const std::string& pref_key) const {
   ExtensionEntryMap::const_iterator winner =
-      GetEffectivePrefValueController(pref_key, false, NULL);
+      GetEffectivePrefValueController(pref_key, false, nullptr);
   if (winner == entries_.end())
     return std::string();
   return winner->first;
 }
 
 void ExtensionPrefValueMap::NotifyInitializationCompleted() {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnInitializationCompleted());
 }
 
 void ExtensionPrefValueMap::NotifyPrefValueChanged(
     const std::set<std::string>& keys) {
   std::set<std::string>::const_iterator i;
   for (i = keys.begin(); i != keys.end(); ++i)
     NotifyPrefValueChanged(*i);
 }
 
 void ExtensionPrefValueMap::NotifyPrefValueChanged(const std::string& key) {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnPrefValueChanged(key));
 }
 
 void ExtensionPrefValueMap::NotifyOfDestruction() {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnExtensionPrefValueMapDestruction());
 }