[Sync] Don't start up sync when FirstSetupCompleted is false and no setup in progress

components/browser_sync/browser/profile_sync_service.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 "components/browser_sync/browser/profile_sync_service.h"
 
 #include <stddef.h>
 #include <cstddef>
 #include <map>
 #include <utility>
@@ skipping 363 matching lines @@
   DCHECK(sync_error_controller_ == NULL)
       << "Initialize() called more than once.";
   sync_error_controller_.reset(new SyncErrorController(this));
   AddObserver(sync_error_controller_.get());
 #endif
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&ProfileSyncService::OnMemoryPressure,
                  sync_enabled_weak_factory_.GetWeakPtr())));
   startup_controller_->Reset(GetRegisteredDataTypes());
-  startup_controller_->TryStart();
+
+  // Auto-start means IsFirstSetupComplete gets set automatically, and the
+  // first startup should be immediate, not deferred.
+  if (start_behavior_ == AUTO_START && !IsFirstSetupComplete()) {
+    SetFirstSetupComplete();
+    startup_controller_->TryStart(true);
+  } else {
+    startup_controller_->TryStart(false);
+  }
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (base::FeatureList::IsEnabled(
           switches::kSyncClearDataOnPassphraseEncryption) &&
       sync_prefs_.GetPassphraseEncryptionTransitionInProgress()) {
     BeginConfigureCatchUpBeforeClear();
     return;
@@ skipping 224 matching lines @@
   token_receive_time_ = base::Time::Now();
   last_get_token_error_ = GoogleServiceAuthError::AuthErrorNone();
 
   if (sync_prefs_.SyncHasAuthError()) {
     sync_prefs_.SetSyncAuthError(false);
   }
 
   if (HasSyncingBackend())
     backend_->UpdateCredentials(GetCredentials());
   else
-    startup_controller_->TryStart();
+    startup_controller_->TryStart(false);
 }
 
 void ProfileSyncService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(access_token_request_.get(), request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   last_get_token_error_ = error;
   switch (error.state()) {
@@ skipping 54 matching lines @@
 
 void ProfileSyncService::OnRefreshTokensLoaded() {
   // This notification gets fired when OAuth2TokenService loads the tokens
   // from storage.
   // Initialize the backend if sync is enabled. If the sync token was
   // not loaded, GetCredentials() will generate invalid credentials to
   // cause the backend to generate an auth error (crbug.com/121755).
   if (HasSyncingBackend()) {
     RequestAccessToken();
   } else {
-    startup_controller_->TryStart();
+    startup_controller_->TryStart(false);
   }
 }
 
 void ProfileSyncService::Shutdown() {
   UnregisterAuthNotifications();
 
   ShutdownImpl(syncer::BROWSER_SHUTDOWN);
   if (sync_error_controller_) {
     // Destroy the SyncErrorController when the service shuts down for good.
     RemoveObserver(sync_error_controller_.get());
@@ skipping 226 matching lines @@
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
   // The very first time the backend initializes is effectively the first time
   // we can say we successfully "synced".  LastSyncedTime will only be null in
   // this case, because the pref wasn't restored on StartUp.
   if (sync_prefs_.GetLastSyncedTime().is_null()) {
     UpdateLastSyncedTime();
   }
 
-  // Auto-start means IsFirstSetupComplete gets set automatically.
-  if (start_behavior_ == AUTO_START && !IsFirstSetupComplete()) {
-    // This will trigger a configure if it completes setup.
-    SetFirstSetupComplete();
-  } else if (CanConfigureDataTypes()) {
+  if (CanConfigureDataTypes())
     ConfigureDataTypeManager();
-  }
 
   // Check for a cookie jar mismatch.
   std::vector<gaia::ListedAccount> accounts;
   std::vector<gaia::ListedAccount> signed_out_accounts;
   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
   if (gaia_cookie_manager_service_ &&
       gaia_cookie_manager_service_->ListAccounts(
           &accounts, &signed_out_accounts)) {
     OnGaiaAccountsInCookieUpdated(accounts, signed_out_accounts, error);
   }
@@ skipping 290 matching lines @@
 #endif
       break;
     case syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT:
       // Sync disabled by domain admin. we should stop syncing until next
       // restart.
       sync_disabled_by_admin_ = true;
       ShutdownImpl(syncer::DISABLE_SYNC);
       break;
     case syncer::RESET_LOCAL_SYNC_DATA:
       ShutdownImpl(syncer::DISABLE_SYNC);
-      startup_controller_->TryStart();
+      startup_controller_->TryStart(false);
       break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 }
 
 void ProfileSyncService::OnLocalSetPassphraseEncryption(
     const syncer::SyncEncryptionHandler::NigoriState& nigori_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 31 matching lines @@
   DCHECK(sync_prefs_.GetPassphraseEncryptionTransitionInProgress());
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(false);
 
   // Call to ClearServerData generates new keystore key on the server. This
   // makes keystore bootstrap token invalid. Let's clear it from preferences.
   sync_prefs_.SetKeystoreEncryptionBootstrapToken(std::string());
 
   // Shutdown sync, delete the Directory, then restart, restoring the cached
   // nigori state.
   ShutdownImpl(syncer::DISABLE_SYNC);
-  startup_controller_->TryStart();
+  startup_controller_->TryStart(true);
 }
 
 void ProfileSyncService::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   configure_status_ = result.status;
   data_type_status_table_ = result.data_type_status_table;
 
   // We should have cleared our cached passphrase before we get here (in
   // OnBackendInitialized()).
   DCHECK(cached_passphrase_.empty());
@@ skipping 726 matching lines @@
   // We may be called during the setup process before we're
   // initialized.  In this case, we default to the sensitive types.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   if (is_sync_managed) {
     StopImpl(CLEAR_DATA);
   } else {
     // Sync is no longer disabled by policy. Try starting it up if appropriate.
-    startup_controller_->TryStart();
+    startup_controller_->TryStart(true);
   }
 }
 
 void ProfileSyncService::GoogleSigninSucceeded(const std::string& account_id,
                                                const std::string& username,
                                                const std::string& password) {
   if (IsSyncRequested() && !password.empty()) {
     cached_passphrase_ = password;
     // Try to consume the passphrase we just cached. If the sync backend
     // is not running yet, the passphrase will remain cached until the
@@ skipping 250 matching lines @@
 void ProfileSyncService::RequestStart() {
   if (!IsSyncAllowed()) {
     // Sync cannot be requested if it's not allowed.
     return;
   }
   DCHECK(sync_client_);
   if (!IsSyncRequested()) {
     sync_prefs_.SetSyncRequested(true);
     NotifyObservers();
   }
-  startup_controller_->TryStart();
+  startup_controller_->TryStart(true);
 }
 
 void ProfileSyncService::ReconfigureDatatypeManager() {
   // If we haven't initialized yet, don't configure the DTM as it could cause
   // association to start before a Directory has even been created.
   if (backend_initialized_) {
     DCHECK(backend_.get());
     ConfigureDataTypeManager();
   } else if (HasUnrecoverableError()) {
     // There is nothing more to configure. So inform the listeners,
@@ skipping 177 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }