Sync: Add a SyncTypePreferenceProvider interface.

chrome/browser/supervised_user/supervised_user_service.cc

 // Copyright 2014 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/supervised_user/supervised_user_service.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 138 matching lines @@
 SupervisedUserService::~SupervisedUserService() {
   DCHECK(did_shutdown_);
 }
 
 void SupervisedUserService::Shutdown() {
   did_shutdown_ = true;
   if (ProfileIsSupervised()) {
     content::RecordAction(UserMetricsAction("ManagedUsers_QuitBrowser"));
   }
   SetActive(false);
+
+  ProfileSyncServiceFactory::GetForProfile(profile_)->RemovePreferenceProvider(
+      this);
 }
 
 bool SupervisedUserService::ProfileIsSupervised() const {
   return profile_->IsSupervised();
 }
 
 // static
 void SupervisedUserService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
@@ skipping 147 matching lines @@
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   if (!extensions::SupervisedUserInfo::GetContentPackSiteList(extension)
            .empty()) {
     UpdateSiteLists();
   }
 }
 #endif  // defined(ENABLE_EXTENSIONS)
 
+syncer::ModelTypeSet SupervisedUserService::GetPreferredDataTypes() {
+  if (!ProfileIsSupervised())
+    return syncer::ModelTypeSet();
+
+  syncer::ModelTypeSet result;
+  result.Put(syncer::SESSIONS);
+  result.Put(syncer::EXTENSIONS);
+  result.Put(syncer::EXTENSION_SETTINGS);
+  result.Put(syncer::APPS);
+  result.Put(syncer::APP_SETTINGS);
+  result.Put(syncer::APP_NOTIFICATIONS);
+  result.Put(syncer::APP_LIST);
+  return result;
+}
+
 void SupervisedUserService::OnStateChanged() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (waiting_for_sync_initialization_ && service->sync_initialized()) {
     waiting_for_sync_initialization_ = false;
     service->RemoveObserver(this);
     FinishSetupSync();
     return;
   }
 
@@ skipping 27 matching lines @@
     service->AddObserver(this);
     waiting_for_sync_initialization_ = true;
   }
 }
 
 void SupervisedUserService::FinishSetupSync() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   DCHECK(service->sync_initialized());
 
+  // Sync nothing (except types which are set via GetPreferredDataTypes).
   bool sync_everything = false;
   syncer::ModelTypeSet synced_datatypes;
-  synced_datatypes.Put(syncer::SESSIONS);
-  synced_datatypes.Put(syncer::APPS);
-  synced_datatypes.Put(syncer::EXTENSIONS);
   service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Notify ProfileSyncService that we are done with configuration.
   service->SetSetupInProgress(false);
   service->SetSyncSetupCompleted();
 }
 
 #if defined(ENABLE_EXTENSIONS)
 bool SupervisedUserService::ExtensionManagementPolicyImpl(
     const extensions::Extension* extension,
@@ skipping 168 matching lines @@
 
 void SupervisedUserService::Init() {
   DCHECK(GetSettingsService()->IsReady());
 
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kSupervisedUserId,
       base::Bind(&SupervisedUserService::OnSupervisedUserIdChanged,
           base::Unretained(this)));
 
+  ProfileSyncServiceFactory::GetForProfile(profile_)->AddPreferenceProvider(
+      this);
+
   SetActive(ProfileIsSupervised());
 }
 
 void SupervisedUserService::SetActive(bool active) {
   if (active_ == active)
     return;
   active_ = active;
 
   if (!delegate_ || !delegate_->SetActive(active_)) {
     if (active_) {
@@ skipping 71 matching lines @@
     BrowserList::AddObserver(this);
 #endif
   } else {
     permissions_creator_.reset();
 
     pref_change_registrar_.Remove(
         prefs::kDefaultSupervisedUserFilteringBehavior);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualHosts);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualURLs);
 
-    if (waiting_for_sync_initialization_) {
-      ProfileSyncService* sync_service =
-          ProfileSyncServiceFactory::GetForProfile(profile_);
-      sync_service->RemoveObserver(this);
-    }
+    if (waiting_for_sync_initialization_)
+      ProfileSyncServiceFactory::GetForProfile(profile_)->RemoveObserver(this);
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::RemoveObserver(this);
 #endif
   }
 }
 
 void SupervisedUserService::RegisterAndInitSync(
@@ skipping 98 matching lines @@
   // The active user can be NULL in unit tests.
   if (chromeos::UserManager::Get()->GetActiveUser()) {
     return UTF16ToUTF8(chromeos::UserManager::Get()->GetUserDisplayName(
         chromeos::UserManager::Get()->GetActiveUser()->GetUserID()));
   }
   return std::string();
 #else
   return profile_->GetPrefs()->GetString(prefs::kProfileName);
 #endif
 }