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 305 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::GetRequiredSyncDataTypes() {
+  if (!ProfileIsSupervised())

[Bernhard Bauer, 2014/07/30 12:38:51]

If we only add ourselves as a data type provider if the profile is supervised,
this method should also only be called if the profile is supervised. DCHECK it?

Actually, we could always register the data type provider. That way we have less
divergence between supervised and unsupervised users.

[Marc Treib, 2014/07/30 13:10:39]

Alright, I'm registering/removing the provider in Init()/Shutdown() now.

+    return syncer::ModelTypeSet();
+
+  return syncer::ModelTypeSet(syncer::SESSIONS,
+                              syncer::APPS,
+                              syncer::EXTENSIONS);
+}
+
 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 GetRequiredSyncDataTypes).
   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 214 matching lines @@
   }
 #endif
 
   SupervisedUserSettingsService* settings_service = GetSettingsService();
   settings_service->SetActive(active_);
 
 #if defined(ENABLE_EXTENSIONS)
   SetExtensionsActive();
 #endif
 
+  ProfileSyncService* sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+
   if (active_) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kPermissionRequestApiUrl)) {
       permissions_creator_ =
           PermissionRequestCreatorApiary::CreateWithProfile(profile_);
     } else {
       PrefService* pref_service = profile_->GetPrefs();
       permissions_creator_.reset(new PermissionRequestCreatorSync(
           settings_service,
           SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile_),
           pref_service->GetString(prefs::kProfileName),
           pref_service->GetString(prefs::kSupervisedUserId)));
     }
 
     pref_change_registrar_.Add(
         prefs::kDefaultSupervisedUserFilteringBehavior,
         base::Bind(&SupervisedUserService::OnDefaultFilteringBehaviorChanged,
             base::Unretained(this)));
     pref_change_registrar_.Add(prefs::kSupervisedUserManualHosts,
         base::Bind(&SupervisedUserService::UpdateManualHosts,
                    base::Unretained(this)));
     pref_change_registrar_.Add(prefs::kSupervisedUserManualURLs,
         base::Bind(&SupervisedUserService::UpdateManualURLs,
                    base::Unretained(this)));
 
+    sync_service->AddDataTypeProvider(this);
+
     // Initialize the filter.
     OnDefaultFilteringBehaviorChanged();
     UpdateSiteLists();
     UpdateManualHosts();
     UpdateManualURLs();
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     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->RemoveDataTypeProvider(this);
+    if (waiting_for_sync_initialization_)
       sync_service->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 85 matching lines @@
 
 void SupervisedUserService::OnBrowserSetLastActive(Browser* browser) {
   bool profile_became_active = profile_->IsSameProfile(browser->profile());
   if (!is_profile_active_ && profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_OpenProfile"));
   else if (is_profile_active_ && !profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_SwitchProfile"));
 
   is_profile_active_ = profile_became_active;
 }