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 123 matching lines @@
 SupervisedUserService::SupervisedUserService(Profile* profile)
     : profile_(profile),
       active_(false),
       delegate_(NULL),
 #if defined(ENABLE_EXTENSIONS)
       extension_registry_observer_(this),
 #endif
       waiting_for_sync_initialization_(false),
       is_profile_active_(false),
       elevated_for_testing_(false),
+      did_init_(false),
       did_shutdown_(false),
       waiting_for_permissions_(false),
       weak_ptr_factory_(this) {
 }
 
 SupervisedUserService::~SupervisedUserService() {
-  DCHECK(did_shutdown_);
+  DCHECK(!did_init_ || did_shutdown_);
 }
 
 void SupervisedUserService::Shutdown() {
+  if (!did_init_ || did_shutdown_)

[Bernhard Bauer, 2014/08/11 08:48:21]

When would we call Shutdown() more than once?

[Marc Treib, 2014/08/11 08:57:09]

Ah, that was unclear - actually I'm not sure if we ever do. But a bunch of tests
create an SUService which they don't Init() but do Shutdown(). See
http://build.chromium.org/p/tryserver.chromium.linux/builders/linux_chromium_....
Given the number of failing tests, it seemed best to make sure here that there
are only matching Init() and Shutdown() calls.

[Bernhard Bauer, 2014/08/11 09:07:13]

I'm not sure what you mean by that -- right now you do handle non-matching
Init() and Shutdown() calls, and as you point out, making sure they always match
might be a lot of work. I don't think we need to handle more than one Shutdown()
though, so I would rather make the second condition into a DCHECK.

[Marc Treib, 2014/08/11 09:35:44]

Done.

+    return;
   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 159 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 160 matching lines @@
 
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   token_service->UpdateCredentials(supervised_users::kSupervisedUserPseudoEmail,
                                    refresh_token);
 
   FinishSetupSyncWhenReady();
 }
 
 void SupervisedUserService::Init() {
+  DCHECK(!did_init_);
+  did_init_ = true;
   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
 }