Client changes for disabled dasher account

chrome/browser/sync/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 "chrome/browser/sync/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 68 matching lines @@
   // implicit types are enabled when their pref group is, or via
   // KeepEverythingSynced.
   for (syncer::ModelTypeSet::Iterator it = user_types.First();
        it.Good(); it.Inc()) {
     RegisterDataTypePreferredPref(registry, it.Get(), false);
   }
 
   registry->RegisterBooleanPref(prefs::kSyncManaged,
                                 false,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kSyncDisabledByAdmin,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
                                std::string(),
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
                                std::string(),
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
   registry->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
                                "",
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
@@ skipping 17 matching lines @@
   model_set.Put(syncer::NIGORI);
   model_set.Put(syncer::SEARCH_ENGINES);
   model_set.Put(syncer::APPS);
   model_set.Put(syncer::TYPED_URLS);
   model_set.Put(syncer::SESSIONS);
   registry->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
                              syncer::ModelTypeSetToValue(model_set),
                              PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
-// static
-bool SyncPrefs::IsSyncAccessibleOnIOThread(ProfileIOData* io_data) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  return ProfileSyncService::IsSyncEnabled() &&
-         !io_data->sync_disabled()->GetValue();
-}
-
 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 110 matching lines @@
        i.Good(); i.Inc()) {
     SetDataTypePreferred(i.Get(), preferred_types.Has(i.Get()));
   }
 }
 
 bool SyncPrefs::IsManaged() const {
   DCHECK(CalledOnValidThread());
   return pref_service_ && pref_service_->GetBoolean(prefs::kSyncManaged);
 }
 
+bool SyncPrefs::IsSyncDisabledByAdmin() const {
+  DCHECK(CalledOnValidThread());
+  return pref_service_ &&
+      pref_service_->GetBoolean(prefs::kSyncDisabledByAdmin);
+}
+
+void SyncPrefs::SetSyncDisabledByAdmin(bool value) {
+  DCHECK(CalledOnValidThread());
+  CHECK(pref_service_);
+  pref_service_->SetBoolean(prefs::kSyncDisabledByAdmin, value);
+}
+
 std::string SyncPrefs::GetEncryptionBootstrapToken() const {
   DCHECK(CalledOnValidThread());
   return pref_service_
              ? pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken)
              : std::string();
 }
 
 void SyncPrefs::SetEncryptionBootstrapToken(const std::string& token) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncEncryptionBootstrapToken, token);
@@ skipping 207 matching lines @@
   for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
       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