Remove PrefService::ScheduleSavePersistentPrefs and SavePersistentPrefs.

chrome/browser/sync/sync_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/sync/sync_prefs.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ skipping 35 matching lines @@
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->ClearPref(prefs::kSyncLastSyncedTime);
   pref_service_->ClearPref(prefs::kSyncHasSetupCompleted);
   pref_service_->ClearPref(prefs::kSyncEncryptionBootstrapToken);
 
   // TODO(nick): The current behavior does not clear
   // e.g. prefs::kSyncBookmarks.  Is that really what we want?
 
   pref_service_->ClearPref(prefs::kSyncMaxInvalidationVersions);
-
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 bool SyncPrefs::HasSyncSetupCompleted() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ &&
       pref_service_->GetBoolean(prefs::kSyncHasSetupCompleted);
 }
 
 void SyncPrefs::SetSyncSetupCompleted() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncHasSetupCompleted, true);
   SetStartSuppressed(false);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 bool SyncPrefs::IsStartSuppressed() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ &&
       pref_service_->GetBoolean(prefs::kSyncSuppressStart);
 }
 
 void SyncPrefs::SetStartSuppressed(bool is_suppressed) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncSuppressStart, is_suppressed);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 std::string SyncPrefs::GetGoogleServicesUsername() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ ?
       pref_service_->GetString(prefs::kGoogleServicesUsername) : "";
 }
 
 base::Time SyncPrefs::GetLastSyncedTime() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       base::Time::FromInternalValue(
           pref_service_ ?
           pref_service_->GetInt64(prefs::kSyncLastSyncedTime) : 0);
 }
 
 void SyncPrefs::SetLastSyncedTime(base::Time time) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetInt64(prefs::kSyncLastSyncedTime, time.ToInternalValue());
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 bool SyncPrefs::HasKeepEverythingSynced() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ &&
       pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced);
 }
 
 void SyncPrefs::SetKeepEverythingSynced(bool keep_everything_synced) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncKeepEverythingSynced,
                             keep_everything_synced);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 syncable::ModelTypeSet SyncPrefs::GetPreferredDataTypes(
     syncable::ModelTypeSet registered_types) const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
     return syncable::ModelTypeSet();
   }
 
   if (pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced)) {
@@ skipping 100 matching lines @@
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ ?
       pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken) : "";
 }
 
 void SyncPrefs::SetEncryptionBootstrapToken(const std::string& token) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetString(prefs::kSyncEncryptionBootstrapToken, token);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 sync_notifier::InvalidationVersionMap SyncPrefs::GetAllMaxVersions() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
     return sync_notifier::InvalidationVersionMap();
   }
   // Complicated gross code to convert from a string -> string
   // DictionaryValue to a ModelType -> int64 map.
   const base::DictionaryValue* max_versions_dict =
@@ skipping 64 matching lines @@
   // Add the types to the current set of acknowledged
   // types, and then store the resulting set in prefs.
   const syncable::ModelTypeSet acknowledged_types =
       Union(types,
             syncable::ModelTypeSetFromValue(
                 *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes)));
 
   scoped_ptr<ListValue> value(
       syncable::ModelTypeSetToValue(acknowledged_types));
   pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 void SyncPrefs::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DCHECK(content::Source<PrefService>(pref_service_) == source);
   switch (type) {
     case chrome::NOTIFICATION_PREF_CHANGED: {
       const std::string* pref_name =
           content::Details<const std::string>(details).ptr();
       if (*pref_name == prefs::kSyncManaged) {
         FOR_EACH_OBSERVER(SyncPrefObserver, sync_pref_observers_,
                           OnSyncManagedPrefChange(*pref_sync_managed_));
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 void SyncPrefs::SetManagedForTest(bool is_managed) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 syncable::ModelTypeSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
     return syncable::ModelTypeSet();
   }
   return syncable::ModelTypeSetFromValue(
       *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes));
 }
@@ skipping 143 matching lines @@
 void SyncPrefs::SetDataTypePreferred(
     syncable::ModelType type, bool is_preferred) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
   pref_service_->SetBoolean(pref_name, is_preferred);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 }  // namespace browser_sync