Add BackupRollbackController for starting backup/rollback

components/sync_driver/sync_prefs.cc

 // Copyright (c) 2012 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 "components/sync_driver/sync_prefs.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
@@ skipping 11 matching lines @@
   DCHECK(pref_service);
   RegisterPrefGroups();
   // Watch the preference that indicates sync is managed so we can take
   // appropriate action.
   pref_sync_managed_.Init(
       prefs::kSyncManaged,
       pref_service_,
       base::Bind(&SyncPrefs::OnSyncManagedPrefChanged, base::Unretained(this)));
 }
 
+SyncPrefs::SyncPrefs() : pref_service_(NULL) {}
+
 SyncPrefs::~SyncPrefs() { DCHECK(CalledOnValidThread()); }
 
 // static
 void SyncPrefs::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kSyncHasSetupCompleted,
       false,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
@@ skipping 86 matching lines @@
   model_set.Put(syncer::NIGORI);
   model_set.Put(syncer::SEARCH_ENGINES);
   model_set.Put(syncer::APPS);
   model_set.Put(syncer::APP_LIST);
   model_set.Put(syncer::TYPED_URLS);
   model_set.Put(syncer::SESSIONS);
   model_set.Put(syncer::ARTICLES);
   registry->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
                              syncer::ModelTypeSetToValue(model_set),
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+
+  registry->RegisterIntegerPref(
+      prefs::kSyncRemainingRollbackTries, 0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 void SyncPrefs::AddSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
   DCHECK(CalledOnValidThread());
   sync_pref_observers_.AddObserver(sync_pref_observer);
 }
 
 void SyncPrefs::RemoveSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
   DCHECK(CalledOnValidThread());
   sync_pref_observers_.RemoveObserver(sync_pref_observer);
@@ skipping 210 matching lines @@
   const syncer::ModelTypeSet acknowledged_types =
       Union(types,
             syncer::ModelTypeSetFromValue(
                 *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes)));
 
   scoped_ptr<base::ListValue> value(
       syncer::ModelTypeSetToValue(acknowledged_types));
   pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
 }
 
+int SyncPrefs::GetRemainingRollbackTries() const {
+  return pref_service_->GetInteger(prefs::kSyncRemainingRollbackTries);
+}
+
+void SyncPrefs::SetRemainingRollbackTries(int times) {
+  pref_service_->SetInteger(prefs::kSyncRemainingRollbackTries, times);
+}
+
 void SyncPrefs::OnSyncManagedPrefChanged() {
   DCHECK(CalledOnValidThread());
   FOR_EACH_OBSERVER(SyncPrefObserver,
                     sync_pref_observers_,
                     OnSyncManagedPrefChange(*pref_sync_managed_));
 }
 
 void SyncPrefs::SetManagedForTest(bool is_managed) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
@@ skipping 87 matching lines @@
        i != pref_groups_.end();
        ++i) {
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync