Implement support for disabling sync through configuration management.

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2010 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/profile_sync_service.h"
 
 #include <map>
 #include <set>
 
 #include "app/l10n_util.h"
@@ skipping 107 matching lines @@
 
 ProfileSyncService::~ProfileSyncService() {
   Shutdown(false);
 }
 
 void ProfileSyncService::Initialize() {
   LOG(INFO) << "Starting ProfileSyncService.";
   InitSettings();
   RegisterPreferences();
 
+  // Watch the preference that indicates sync is managed so we can take
+  // appropriate action.
+  pref_sync_managed_.Init(prefs::kSyncManaged, profile_->GetPrefs(), this);
+
+  // For now, the only thing we can do through policy is to turn sync off.
+  if (IsManaged()) {
+    DisableForUser();
+    return;
+  }
+
   if (!profile()->GetPrefs()->GetBoolean(prefs::kSyncHasSetupCompleted)) {
     DisableForUser();  // Clean up in case of previous crash / setup abort.
 
     // Automatically start sync in Chromium OS.
     if (bootstrap_sync_authentication_) {
       // If the LSID is empty, we're in a CrOS UI test that is not testing sync
       // behavior, so we don't want the sync service to start.
       if (GetLsidForAuthBootstraping().empty()) {
         LOG(WARNING) << "Skipping CrOS sync startup, no LSID present.";
         return;
@@ skipping 71 matching lines @@
   pref_service->RegisterBooleanPref(prefs::kSyncBookmarks, true);
   pref_service->RegisterBooleanPref(prefs::kSyncPasswords, enable_by_default);
   pref_service->RegisterBooleanPref(prefs::kSyncPreferences, enable_by_default);
   pref_service->RegisterBooleanPref(prefs::kSyncAutofill, enable_by_default);
   pref_service->RegisterBooleanPref(prefs::kSyncThemes, enable_by_default);
   pref_service->RegisterBooleanPref(prefs::kSyncTypedUrls, enable_by_default);
   pref_service->RegisterBooleanPref(prefs::kSyncExtensions, enable_by_default);
 
   pref_service->RegisterBooleanPref(prefs::kKeepEverythingSynced,
       enable_by_default);
+
+  pref_service->RegisterBooleanPref(prefs::kSyncManaged, false);
 }
 
 void ProfileSyncService::ClearPreferences() {
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->ClearPref(prefs::kSyncLastSyncedTime);
   pref_service->ClearPref(prefs::kSyncHasSetupCompleted);
   // TODO(nick): The current behavior does not clear e.g. prefs::kSyncBookmarks.
   // Is that really what we want?
   pref_service->ScheduleSavePersistentPrefs();
 }
@@ skipping 516 matching lines @@
     case NotificationType::SYNC_PASSPHRASE_ACCEPTED: {
       // Make sure the data types that depend on the passphrase are started at
       // this time.
       syncable::ModelTypeSet types;
       GetPreferredDataTypes(&types);
       data_type_manager_->Configure(types);
 
       FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
       break;
     }
+    case NotificationType::PREF_CHANGED: {
+      std::wstring* pref_name = Details<std::wstring>(details).ptr();
+      if (*pref_name == prefs::kSyncManaged) {
+        FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
+        if (*pref_sync_managed_)
+          DisableForUser();
+        else if (HasSyncSetupCompleted())
+          StartUp();
+      }
+      break;
+    }
     default: {
       NOTREACHED();
     }
   }
 }
 
 void ProfileSyncService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ProfileSyncService::SyncEvent(SyncEventCodes code) {
   UMA_HISTOGRAM_ENUMERATION("Sync.EventCodes", code, MAX_SYNC_EVENT_CODE);
 }
 
+// static
 bool ProfileSyncService::IsSyncEnabled() {
   // We have switches::kEnableSync just in case we need to change back to
   // sync-disabled-by-default on a platform.
   return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableSync);
 }
 
+bool ProfileSyncService::IsManaged() {
+  // Some tests use ProfileSyncServiceMock which doesn't have a profile.
+  return profile_ && profile_->GetPrefs()->GetBoolean(prefs::kSyncManaged);
+}
+
 bool ProfileSyncService::ShouldPushChanges() {
   // True only after all bootstrapping has succeeded: the sync backend
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }