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 "build/build_config.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 31 matching lines @@
 
 void SyncPrefs::ClearPreferences() {
   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_->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();
 }
 
 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(
     const syncable::ModelTypeSet& registered_types) const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
     return syncable::ModelTypeSet();
   }
 
   if (pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced)) {
@@ skipping 61 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();
 }
 
 void SyncPrefs::AcknowledgeSyncedTypes(
     const syncable::ModelTypeSet& types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   syncable::ModelTypeSet acknowledged_types =
       syncable::ModelTypeSetFromValue(
           *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes));
 
   // Add the types to the current set of acknowledged
   // types, and then store the resulting set in prefs.
   {
     syncable::ModelTypeSet temp;
     std::set_union(acknowledged_types.begin(), acknowledged_types.end(),
                    types.begin(), types.end(),
                    std::inserter(temp, temp.end()));
     std::swap(acknowledged_types, temp);
   }
 
   scoped_ptr<ListValue> value(
       syncable::ModelTypeSetToValue(acknowledged_types));
   pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
-  pref_service_->ScheduleSavePersistentPrefs();
 }
 
 void SyncPrefs::Observe(int type,
                         const NotificationSource& source,
                         const NotificationDetails& details) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DCHECK(Source<PrefService>(pref_service_) == source);
   switch (type) {
     case chrome::NOTIFICATION_PREF_CHANGED: {
       const std::string* pref_name =
           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 138 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