[sync] Apply sync config changes only after sync backend is initialized

chrome/browser/sync/credential_cache_service_win.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/credential_cache_service_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/base64.h"
 #include "base/command_line.h"
@@ skipping 120 matching lines @@
 
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL: {
       // The user has signed in. Write the new value of the google username to
       // the local cache.
       SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
       PackAndUpdateStringPref(prefs::kGoogleServicesUsername,
                               signin->GetAuthenticatedUsername());
       break;
     }
 
+    case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE: {
+      // Local sync configuration is done. The sync service is now ready to
+      // be reconfigured. Immediately look for any unconsumed config changes in
+      // the alternate profile. If all changes have been consumed, this is a
+      // no-op.
+      ScheduleNextReadFromAlternateCredentialCache(0);
+      break;
+    }
+
     case chrome::NOTIFICATION_SYNC_CONFIGURE_START: {
       // We have detected a sync sign in, auto-start or reconfigure. Write the
       // latest sync preferences to the local cache.
       WriteSyncPrefsToLocalCache();
       break;
     }
 
     case chrome::NOTIFICATION_TOKEN_LOADING_FINISHED: {
       // The token service has been fully initialized. Update the token service
       // credentials in the local cache. This is a no-op if the cache already
@@ skipping 49 matching lines @@
   DCHECK(alternate_store_.get());
   if (!HasPref(alternate_store_, prefs::kGoogleServicesUsername) ||
       !HasPref(alternate_store_, GaiaConstants::kGaiaLsid) ||
       !HasPref(alternate_store_, GaiaConstants::kGaiaSid) ||
       !(HasPref(alternate_store_, prefs::kSyncEncryptionBootstrapToken) ||
         HasPref(alternate_store_,
                 prefs::kSyncKeystoreEncryptionBootstrapToken)) ||
       !HasPref(alternate_store_, prefs::kSyncKeepEverythingSynced)) {
     VLOG(1) << "Could not find cached credentials in \""
             << GetCredentialPathInAlternateProfile().value() << "\".";
-    ScheduleNextReadFromAlternateCredentialCache();
+    ScheduleNextReadFromAlternateCredentialCache(
+        kCredentialCachePollIntervalSecs);
     return;
   }
 
   // Extract the google username, lsid and sid from the alternate credential
   // cache.
   std::string alternate_google_services_username =
       GetAndUnpackStringPref(alternate_store_, prefs::kGoogleServicesUsername);
   std::string alternate_lsid =
       GetAndUnpackStringPref(alternate_store_, GaiaConstants::kGaiaLsid);
   std::string alternate_sid =
@@ skipping 85 matching lines @@
         alternate_google_services_username,
         alternate_encryption_bootstrap_token,
         alternate_keystore_encryption_bootstrap_token,
         alternate_keep_everything_synced,
         alternate_preferred_types);
     UpdateTokenServiceCredentials(alternate_lsid, alternate_sid);
   }
 
   // Schedule the next read from the alternate credential cache so that we can
   // detect future reconfigures or sign outs.
-  ScheduleNextReadFromAlternateCredentialCache();
+  ScheduleNextReadFromAlternateCredentialCache(
+      kCredentialCachePollIntervalSecs);
 }
 
 void CredentialCacheService::WriteSyncPrefsToLocalCache() {
   UpdateBooleanPref(prefs::kSyncKeepEverythingSynced,
                     sync_prefs_.HasKeepEverythingSynced());
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   ModelTypeSet registered_types = service->GetRegisteredDataTypes();
   for (ModelTypeSet::Iterator it = registered_types.First();
        it.Good();
        it.Inc()) {
     std::string datatype_pref_name =
         browser_sync::SyncPrefs::GetPrefNameForDataType(it.Get());
     UpdateBooleanPref(
         datatype_pref_name,
         profile_->GetPrefs()->GetBoolean(datatype_pref_name.c_str()));
   }
 }
 
-void CredentialCacheService::ScheduleNextReadFromAlternateCredentialCache() {
+void CredentialCacheService::ScheduleNextReadFromAlternateCredentialCache(
+    int delay_secs) {
+  DCHECK_LE(0, delay_secs);
   // We must reinitialize |alternate_store_| here because the underlying
   // credential file in the alternate profile might have changed, and we must
   // re-read it afresh.
   alternate_store_observer_.release();
   alternate_store_.release();
   next_read_.Reset(base::Bind(
       &CredentialCacheService::LookForCachedCredentialsInAlternateProfile,
       weak_factory_.GetWeakPtr()));
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       next_read_.callback(),
-      TimeDelta::FromSeconds(kCredentialCachePollIntervalSecs));
+      TimeDelta::FromSeconds(delay_secs));
 }
 
 bool CredentialCacheService::HasPref(scoped_refptr<JsonPrefStore> store,
                                      const std::string& pref_name) {
   return (store->GetValue(pref_name, NULL) == PrefStore::READ_OK);
 }
 
 // static
 base::StringValue* CredentialCacheService::PackCredential(
     const std::string& credential) {
@@ skipping 221 matching lines @@
 }
 
 void CredentialCacheService::AlternateStoreObserver::OnInitializationCompleted(
     bool succeeded) {
   // If an alternate credential cache was found, begin consuming its contents.
   // If not, schedule a future read.
   if (succeeded &&
       alternate_store_->GetReadError() == JsonPrefStore::PREF_READ_ERROR_NONE) {
     service_->ReadCachedCredentialsFromAlternateProfile();
   } else {
-    service_->ScheduleNextReadFromAlternateCredentialCache();
+    service_->ScheduleNextReadFromAlternateCredentialCache(
+        kCredentialCachePollIntervalSecs);
   }
 }
 
 void CredentialCacheService::AlternateStoreObserver::OnPrefValueChanged(
     const std::string& key) {
   // Nothing to do here, since credentials are cached silently.
 }
 
 FilePath CredentialCacheService::GetCredentialPathInCurrentProfile() const {
   // The sync credential path in the default Desktop profile is
@@ skipping 41 matching lines @@
                  content::Source<Profile>(profile_));
   registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
                  content::Source<Profile>(profile_));
 
   // Register for notifications for sync configuration changes that could occur
   // during sign in or reconfiguration.
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   registrar_.Add(this,
+                 chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
+                 content::Source<ProfileSyncService>(service));
+  registrar_.Add(this,
                  chrome::NOTIFICATION_SYNC_CONFIGURE_START,
                  content::Source<ProfileSyncService>(service));
 
   // Register for notifications for updates to the sync encryption tokens, which
   // are stored in the PrefStore.
   pref_registrar_.Init(profile_->GetPrefs());
   pref_registrar_.Add(prefs::kSyncEncryptionBootstrapToken, this);
   pref_registrar_.Add(prefs::kSyncKeystoreEncryptionBootstrapToken, this);
 
   // Register for notifications for updates to lsid and sid, which are stored in
@@ skipping 84 matching lines @@
 
 void CredentialCacheService::InitiateSignOut() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   service->DisableForUser();
 }
 
 bool CredentialCacheService::HaveSyncPrefsChanged(
     bool alternate_keep_everything_synced,
     ModelTypeSet alternate_preferred_types) const {
+  if (alternate_keep_everything_synced &&
+      sync_prefs_.HasKeepEverythingSynced()) {
+    return false;
+  }
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   ModelTypeSet local_preferred_types =
       sync_prefs_.GetPreferredDataTypes(service->GetRegisteredDataTypes());
   return
       (alternate_keep_everything_synced !=
        sync_prefs_.HasKeepEverythingSynced()) ||
       !alternate_preferred_types.Equals(local_preferred_types);
 }
 
@@ skipping 46 matching lines @@
 }
 
 bool CredentialCacheService::MayReconfigureSync(
     const std::string& alternate_google_services_username) {
   // We may attempt to reconfigure sync iff:
   // 1) The user is signed in to the local profile.
   // 2) The user has never signed out of the local profile in the past.
   // 3) The user is signed in to the alternate profile with the same account.
   // 4) The user is not already in the process of configuring sync.
   // 5) The alternate cache was updated more recently than the local cache.
+  // 6) The sync backend is initialized and ready to consume config changes.
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   return !service->signin()->GetAuthenticatedUsername().empty() &&
          !HasUserSignedOut() &&
          (alternate_google_services_username ==
           service->signin()->GetAuthenticatedUsername()) &&
          !service->setup_in_progress() &&
-         AlternateCacheIsMoreRecent();
+         AlternateCacheIsMoreRecent() &&
+         service->sync_initialized();

[Nicolas Zea, 2012/08/23 23:00:48]

would should push changes be more appropriate here?

[Raghu Simha, 2012/08/23 23:15:20]

Good idea. Makes sense to wait for local config to be done before applying any
external config changes. Done.

 }
 
 bool CredentialCacheService::ShouldSignInToSync(
     const std::string& alternate_google_services_username,
     const std::string& alternate_lsid,
     const std::string& alternate_sid,
     const std::string& alternate_encryption_bootstrap_token,
     const std::string& alternate_keystore_encryption_bootstrap_token) {
   // We should sign in with cached credentials from the alternate profile iff:
   // 1) The user is not currently signed in to the local profile.
   // 2) The user has never signed out of the local profile in the past.
   // 3) Valid cached credentials are available in the alternate profile.
   // 4) The user is not already in the process of configuring sync.
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   return service->signin()->GetAuthenticatedUsername().empty() &&
          !HasUserSignedOut() &&
          !alternate_google_services_username.empty() &&
          !alternate_lsid.empty() &&
          !alternate_sid.empty() &&
          !(alternate_encryption_bootstrap_token.empty() &&
            alternate_keystore_encryption_bootstrap_token.empty()) &&
          !service->setup_in_progress();
 }
 
 }  // namespace syncer