Remove PrefService::ScheduleSavePersistentPrefs and SavePersistentPrefs.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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 "chrome/browser/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 141 matching lines @@
 
 // A preference that contains extension-set content settings.
 const char kPrefIncognitoContentSettings[] = "incognito_content_settings";
 
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
-    prefs_(service),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
-    prefs_->ScheduleSavePersistentPrefs();
   }
 
   virtual DictionaryValue* Get() {
     DictionaryValue* dict = DictionaryPrefUpdate::Get();
     DictionaryValue* extension = NULL;
     if (!dict->GetDictionary(extension_id_, &extension)) {
       // Extension pref does not exist, create it.
       extension = new DictionaryValue();
       dict->Set(extension_id_, extension);
     }
     return extension;
   }
 
  private:
-  PrefService* prefs_;
   const std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionPrefUpdate);
 };
 
 // Provider of write access to a dictionary storing extension controlled prefs.
 class ScopedExtensionControlledPrefUpdate : public DictionaryPrefUpdate {
  public:
   // |incognito_or_regular_path| indicates the sub-path where the
   // extension controlled preferences are stored. This has to be either
   // kPrefPreferences or kPrefIncognitoPreferences.
   ScopedExtensionControlledPrefUpdate(
       PrefService* service,
       const std::string& extension_id,
       const std::string& incognito_or_regular_path) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
-    prefs_(service),
     extension_id_(extension_id),
     incognito_or_regular_path_(incognito_or_regular_path) {}
 
   virtual ~ScopedExtensionControlledPrefUpdate() {
-    prefs_->ScheduleSavePersistentPrefs();
   }
 
   virtual DictionaryValue* Get() {
     DictionaryValue* dict = DictionaryPrefUpdate::Get();
     DictionaryValue* preferences = NULL;
     std::string key =
         extension_id_ + std::string(".") + incognito_or_regular_path_;
     if (!dict->GetDictionary(key, &preferences)) {
       preferences = new DictionaryValue;
       dict->Set(key, preferences);
     }
     return preferences;
   }
 
  private:
-  PrefService* prefs_;
   const std::string extension_id_;
   const std::string incognito_or_regular_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionControlledPrefUpdate);
 };
 
 std::string JoinPrefs(std::string parent, const char* child) {
   return parent + "." + child;
 }
 
@@ skipping 73 matching lines @@
     if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
       NOTREACHED() << "Control should never reach here for extension " << *i;
       continue;
     }
     FilePath::StringType path_string;
     extension_dict->GetString(kPrefPath, &path_string);
     FilePath path(path_string);
     extension_dict->SetString(kPrefPath,
         MakePathRelative(install_directory_, path));
   }
-  SavePrefs();
 }
 
 void ExtensionPrefs::MakePathsAbsolute(DictionaryValue* dict) {
   if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     DictionaryValue* extension_dict = NULL;
     if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
@@ skipping 185 matching lines @@
   }
 
   // Set the scriptable host permissions.
   if (!new_value->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefScriptableHosts),
                                   new_value->scriptable_hosts());
   }
 }
 
-void ExtensionPrefs::SavePrefs() {
-  prefs_->ScheduleSavePersistentPrefs();
-}
-
 // static
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionOrphaned(const std::string& extension_id) {
@@ skipping 466 matching lines @@
 
 void ExtensionPrefs::SetToolbarOrder(
     const std::vector<std::string>& extension_ids) {
   ListPrefUpdate update(prefs_, kExtensionToolbar);
   ListValue* toolbar_order = update.Get();
   toolbar_order->Clear();
   for (std::vector<std::string>::const_iterator iter = extension_ids.begin();
        iter != extension_ids.end(); ++iter) {
     toolbar_order->Append(new StringValue(*iter));
   }
-  SavePrefs();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool from_webstore,
     int page_index) {
   const std::string& id = extension->id();
   CHECK(Extension::IdIsValid(id));
   ScopedExtensionPrefUpdate update(prefs_, id);
@@ skipping 143 matching lines @@
     update->Set(key, data_value);
   else
     update->Remove(key, NULL);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   extension_pref_value_map_->UnregisterExtension(extension_id);
   content_settings_store_->UnregisterExtension(extension_id);
   DictionaryPrefUpdate update(prefs_, kExtensionsPref);
   DictionaryValue* dict = update.Get();
-  if (dict->HasKey(extension_id)) {
-    dict->Remove(extension_id, NULL);
-    SavePrefs();
-  }
+  dict->Remove(extension_id, NULL);
 }
 
 const DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict)
     return NULL;
   DictionaryValue* extension = NULL;
   dict->GetDictionary(extension_id, &extension);
   return extension;
@@ skipping 186 matching lines @@
 bool ExtensionPrefs::GetWebStoreLogin(std::string* result) {
   if (prefs_->HasPrefPath(kWebStoreLogin)) {
     *result = prefs_->GetString(kWebStoreLogin);
     return true;
   }
   return false;
 }
 
 void ExtensionPrefs::SetWebStoreLogin(const std::string& login) {
   prefs_->SetString(kWebStoreLogin, login);
-  SavePrefs();
 }
 
 int ExtensionPrefs::GetAppLaunchIndex(const std::string& extension_id) {
   int value;
   if (ReadExtensionPrefInteger(extension_id, kPrefAppLaunchIndex, &value))
     return value;
 
   return -1;
 }
 
@@ skipping 376 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }