sync: final pieces to sync deferred initialization

chrome/browser/sync/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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 80 matching lines @@
 
 #if defined(OS_ANDROID)
 #include "sync/internal_api/public/read_transaction.h"
 #endif
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::FailedDataTypesHandler;
 using browser_sync::NotificationServiceSessionsRouter;
+using browser_sync::ProfileSyncServiceStartBehavior;
 using browser_sync::SyncBackendHost;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 using syncer::JsBackend;
 using syncer::JsController;
 using syncer::JsEventDetails;
 using syncer::JsEventHandler;
 using syncer::ModelSafeRoutingInfo;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
@@ skipping 43 matching lines @@
   return (error.action != syncer::UNKNOWN_ACTION &&
           error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT);
 }
 
 ProfileSyncService::ProfileSyncService(
     ProfileSyncComponentsFactory* factory,
     Profile* profile,
     ManagedUserSigninManagerWrapper* signin_wrapper,
     ProfileOAuth2TokenService* oauth2_token_service,
-    StartBehavior start_behavior)
+    ProfileSyncServiceStartBehavior start_behavior)
     : OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       sync_prefs_(profile_->GetPrefs()),
       sync_service_url_(kDevServerUrl),
-      data_type_requested_sync_startup_(false),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       signin_(signin_wrapper),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_(false),
       encryption_pending_(false),
-      auto_start_enabled_(start_behavior == AUTO_START),
       configure_status_(DataTypeManager::UNKNOWN),
-      setup_in_progress_(false),
       oauth2_token_service_(oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       weak_factory_(this),
+      startup_controller_weak_factory_(this),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
       last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()),
-      network_resources_(new syncer::HttpBridgeNetworkResources) {
+      network_resources_(new syncer::HttpBridgeNetworkResources),
+      startup_controller_(
+          start_behavior, oauth2_token_service, &sync_prefs_, signin_wrapper,
+          base::Bind(
+              &ProfileSyncService::StartUpSlowBackendComponents,
+              startup_controller_weak_factory_.GetWeakPtr())) {
   DCHECK(profile);
   // By default, dev, canary, and unbranded Chromium users will go to the
   // development servers. Development servers have more features than standard
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
   //
   // GetChannel hits the registry on Windows. See http://crbug.com/70380.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
@@ skipping 72 matching lines @@
 
 #if !defined(OS_ANDROID)
    if (!sync_global_error_) {
      sync_global_error_.reset(new SyncGlobalError(this, signin()));
      GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
          sync_global_error_.get());
      AddObserver(sync_global_error_.get());
    }
 #endif
 
-  TryStart();
+  startup_controller_.TryStart();
 }
 
 void ProfileSyncService::TrySyncDatatypePrefRecovery() {
   DCHECK(!sync_initialized());
   if (!HasSyncSetupCompleted())
     return;
 
   // There was a bug where OnUserChoseDatatypes was not properly called on
   // configuration (see crbug.com/154940). We detect this by checking whether
   // kSyncKeepEverythingSynced has a default value. If so, and sync setup has
@@ skipping 14 matching lines @@
 
   // kSyncKeepEverythingSynced was not properly set. Set it and the preferred
   // types now, before we configure.
   UMA_HISTOGRAM_COUNTS("Sync.DatatypePrefRecovery", 1);
   sync_prefs_.SetKeepEverythingSynced(true);
   syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_types);
 }
 
-void ProfileSyncService::TryStart() {
-  if (!IsSyncEnabledAndLoggedIn())
-    return;
-
-  // Don't start sync until tokens are loaded, because the user can be
-  // "signed in" long before the tokens get loaded, and we don't want to
-  // generate spurious auth errors.
-  if (!IsOAuthRefreshTokenAvailable())
-    return;
-
-  // If we got here then tokens are loaded and user logged in and sync is
-  // enabled. If OAuth refresh token is not available then something is wrong.
-  // When PSS requests access token, OAuth2TokenService will return error and
-  // PSS will show error to user asking to reauthenticate.
-  UMA_HISTOGRAM_BOOLEAN("Sync.RefreshTokenAvailable",
-      IsOAuthRefreshTokenAvailable());
-
-  // If sync setup has completed we always start the backend. If the user is in
-  // the process of setting up now, we should start the backend to download
-  // account control state / encryption information). If autostart is enabled,
-  // but we haven't completed sync setup, we try to start sync anyway, since
-  // it's possible we crashed/shutdown after logging in but before the backend
-  // finished initializing the last time.
-  //
-  // However, the only time we actually need to start sync _immediately_ is if
-  // we haven't completed sync setup and the user is in the process of setting
-  // up - either they just signed in (for the first time) on an auto-start
-  // platform or they explicitly kicked off sync setup, and e.g we need to
-  // fetch account details like encryption state to populate UI. Otherwise,
-  // for performance reasons and maximizing parallelism at chrome startup, we
-  // defer the heavy lifting for sync init until things have calmed down.
-  if (HasSyncSetupCompleted()) {
-    if (!data_type_requested_sync_startup_)
-      StartUp(STARTUP_BACKEND_DEFERRED);
-    else if (start_up_time_.is_null())
-      StartUp(STARTUP_IMMEDIATE);
-    else
-      StartUpSlowBackendComponents();
-  } else if (setup_in_progress_ || auto_start_enabled_) {
-    // We haven't completed sync setup. Start immediately if the user explicitly
-    // kicked this off or we're supposed to automatically start syncing.
-    StartUp(STARTUP_IMMEDIATE);
-  }
-}
-
 void ProfileSyncService::StartSyncingWithServer() {
   if (backend_)
     backend_->StartSyncingWithServer();
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   oauth2_token_service_->AddObserver(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
@@ skipping 215 matching lines @@
 
 void ProfileSyncService::OnSyncConfigureRetry() {
   // Note: in order to handle auth failures that arise before the backend is
   // initialized (e.g. from invalidation notifier, or downloading new control
   // types), we have to gracefully handle configuration retries at all times.
   // At this point an auth error badge should be shown, which once resolved
   // will trigger a new sync cycle.
   NotifyObservers();
 }
 
-void ProfileSyncService::StartUp(StartUpDeferredOption deferred_option) {
-  // Don't start up multiple times.
-  if (backend_) {
-    DVLOG(1) << "Skipping bringing up backend host.";
-    return;
-  }
-
-  DCHECK(IsSyncEnabledAndLoggedIn());
-
-  if (start_up_time_.is_null()) {
-    start_up_time_ = base::Time::Now();
-  } else {
-    // We don't care to prevent multiple calls to StartUp in deferred mode
-    // because it's fast and has no side effects.
-    DCHECK_EQ(STARTUP_BACKEND_DEFERRED, deferred_option);
-  }
-
-  if (deferred_option == STARTUP_BACKEND_DEFERRED &&
-      CommandLine::ForCurrentProcess()->
-          HasSwitch(switches::kSyncEnableDeferredStartup)) {
-    return;
-  }
-
-  StartUpSlowBackendComponents();
-}
-
 void ProfileSyncService::OnDataTypeRequestsSyncStartup(
     syncer::ModelType type) {
   DCHECK(syncer::UserTypes().Has(type));
   if (backend_.get()) {
     DVLOG(1) << "A data type requested sync startup, but it looks like "
                 "something else beat it to the punch.";
     return;
   }
 
   if (!GetActiveDataTypes().Has(type)) {
     // We can get here as datatype SyncableServices are typically wired up
     // to the native datatype even if sync isn't enabled.
     DVLOG(1) << "Dropping sync startup request because type "
              << syncer::ModelTypeToString(type) << "not enabled.";
     return;
   }
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSyncEnableDeferredStartup)) {
-    DVLOG(2) << "Data type requesting sync startup: "
-             << syncer::ModelTypeToString(type);
-    // Measure the time spent waiting for init and the type that triggered it.
-    // We could measure the time spent deferred on a per-datatype basis, but
-    // for now this is probably sufficient.
-    if (!start_up_time_.is_null()) {
-      // TODO(tim): Cache |type| and move this tracking to StartUp.  I'd like
-      // to pull all the complicated init logic and state out of
-      // ProfileSyncService and have only a StartUp method, though. One step
-      // at a time. Bug 80149.
-      base::TimeDelta time_deferred = base::Time::Now() - start_up_time_;
-      UMA_HISTOGRAM_TIMES("Sync.Startup.TimeDeferred", time_deferred);
-      UMA_HISTOGRAM_ENUMERATION("Sync.Startup.TypeTriggeringInit",
-                                ModelTypeToHistogramInt(type),
-                                syncer::MODEL_TYPE_COUNT);
-    }
-    data_type_requested_sync_startup_ = true;
-    TryStart();
-  }
-  DVLOG(2) << "Ignoring data type request for sync startup: "
-           << syncer::ModelTypeToString(type);
+  startup_controller_.OnDataTypeRequestsSyncStartup(type);
 }
 
 void ProfileSyncService::StartUpSlowBackendComponents() {
   // Don't start up multiple times.
-  if (backend_) {
-    DVLOG(1) << "Skipping bringing up backend host.";
-    return;
-  }
+  DCHECK(!backend_);
 
   DCHECK(IsSyncEnabledAndLoggedIn());
+
+  DCHECK(!sync_disabled_by_admin_);
   backend_.reset(
       factory_->CreateSyncBackendHost(
           profile_->GetDebugName(),
           profile_,
           sync_prefs_.AsWeakPtr()));
 
   // Initialize the backend.  Every time we start up a new SyncBackendHost,
   // we'll want to start from a fresh SyncDB, so delete any old one that might
   // be there.
   InitializeBackend(!HasSyncSetupCompleted());
@@ skipping 12 matching lines @@
   if (sync_prefs_.SyncHasAuthError()) {
     sync_prefs_.SetSyncAuthError(false);
     UMA_HISTOGRAM_ENUMERATION("Sync.SyncAuthError",
                               AUTH_ERROR_FIXED,
                               AUTH_ERROR_LIMIT);
   }
 
   if (backend_)
     backend_->UpdateCredentials(GetCredentials());
   else
-    TryStart();
+    startup_controller_.TryStart();
 }
 
 void ProfileSyncService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(access_token_request_, request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   last_get_token_error_ = error;
   switch (error.state()) {
@@ skipping 51 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 (backend_) {
     RequestAccessToken();
   } else {
-    TryStart();
+    startup_controller_.TryStart();
   }
 }
 
 void ProfileSyncService::Shutdown() {
   UnregisterAuthNotifications();
 
   ShutdownImpl(browser_sync::SyncBackendHost::STOP);
 
   if (sync_thread_)
     sync_thread_->Stop();
@@ skipping 41 matching lines @@
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend) {
     sync_thread_ = doomed_backend->Shutdown(option);
     doomed_backend.reset();
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
+  startup_controller_.Reset();
+
   // Clear various flags.
-  start_up_time_ = base::Time();
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
   cached_passphrase_.clear();
   access_token_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   request_access_token_retry_timer_.Stop();
@@ skipping 124 matching lines @@
         debug_info_listener,
     bool success) {
   is_first_time_sync_configure_ = !HasSyncSetupCompleted();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
-  DCHECK(!start_up_time_.is_null());
   base::Time on_backend_initialized_time = base::Time::Now();
-  base::TimeDelta delta = on_backend_initialized_time - start_up_time_;
+  base::TimeDelta delta = on_backend_initialized_time -
+      startup_controller_.start_backend_time();
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: stop syncing at once
     // and surface error UI to alert the user sync has stopped.
     // Keep the directory around for now so that on restart we will retry
@@ skipping 23 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".  last_synced_time_ will only be null
   // in this case, because the pref wasn't restored on StartUp.
   if (last_synced_time_.is_null()) {
     UpdateLastSyncedTime();
   }
 
-  if (auto_start_enabled_ && !FirstSetupInProgress()) {
+  if (startup_controller_.auto_start_enabled() && !FirstSetupInProgress()) {
     // Backend is initialized but we're not in sync setup, so this must be an
     // autostart - mark our sync setup as completed and we'll start syncing
     // below.
     SetSyncSetupCompleted();
   }
 
   // Check HasSyncSetupCompleted() before NotifyObservers() to avoid spurious
   // data type configuration because observer may flag setup as complete and
   // trigger data type configuration.
   if (HasSyncSetupCompleted()) {
@@ skipping 288 matching lines @@
   DCHECK_NE(last_actionable_error_.action,
             syncer::UNKNOWN_ACTION);
   switch (error.action) {
     case syncer::UPGRADE_CLIENT:
     case syncer::CLEAR_USER_DATA_AND_RESYNC:
     case syncer::ENABLE_SYNC_ON_ACCOUNT:
     case syncer::STOP_AND_RESTART_SYNC:
       // TODO(lipalani) : if setup in progress we want to display these
       // actions in the popup. The current experience might not be optimal for
       // the user. We just dismiss the dialog.
-      if (setup_in_progress_) {
+      if (startup_controller_.setup_in_progress()) {
         StopSyncingPermanently();
         expect_sync_configuration_aborted_ = true;
       }
       // Trigger an unrecoverable error to stop syncing.
       OnInternalUnrecoverableError(FROM_HERE,
                                    last_actionable_error_.error_description,
                                    true,
                                    ERROR_REASON_ACTIONABLE_ERROR);
       break;
     case syncer::DISABLE_SYNC_ON_CLIENT:
       StopSyncingPermanently();
 #if !defined(OS_CHROMEOS)
       // On desktop Chrome, sign out the user after a dashboard clear.
-      // TODO(rsimha): Revisit this for M30. See http://crbug.com/252049.
-      if (!auto_start_enabled_)  // Skip sign out on ChromeOS/Android.
+      // Skip sign out on ChromeOS/Android.
+      if (!startup_controller_.auto_start_enabled())
         SigninManagerFactory::GetForProfile(profile_)->SignOut();
 #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(browser_sync::SyncBackendHost::DISABLE_AND_CLAIM_THREAD);
       break;
     default:
@@ skipping 134 matching lines @@
     case DATATYPES_NOT_INITIALIZED:
       return "Datatypes not fully initialized";
     case INITIALIZED:
       return "Sync service initialized";
     default:
       return "Status unknown: Internal error?";
   }
 }
 
 std::string ProfileSyncService::GetBackendInitializationStateString() const {
-  if (sync_initialized())
-    return "Done";
-  else if (!start_up_time_.is_null())
-    return "Deferred";
-  else
-    return "Not started";
+  return startup_controller_.GetBackendInitializationStateString();
+}
+
+bool ProfileSyncService::auto_start_enabled() const {
+  return startup_controller_.auto_start_enabled();
+}
+
+bool ProfileSyncService::setup_in_progress() const {
+  return startup_controller_.setup_in_progress();
 }
 
 bool ProfileSyncService::QueryDetailedSyncStatus(
     SyncBackendHost::Status* result) {
   if (backend_.get() && backend_initialized_) {
     *result = backend_->GetDetailedStatus();
     return true;
   } else {
     SyncBackendHost::Status status;
     status.sync_protocol_error = last_actionable_error_;
     *result = status;
     return false;
   }
 }
 
 const AuthError& ProfileSyncService::GetAuthError() const {
   return last_auth_error_;
 }
 
 bool ProfileSyncService::FirstSetupInProgress() const {
-  return !HasSyncSetupCompleted() && setup_in_progress_;
+  return !HasSyncSetupCompleted() && startup_controller_.setup_in_progress();
 }
 
 void ProfileSyncService::SetSetupInProgress(bool setup_in_progress) {
   // This method is a no-op if |setup_in_progress_| remains unchanged.
-  if (setup_in_progress_ == setup_in_progress)
+  if (startup_controller_.setup_in_progress() == setup_in_progress)
     return;
 
-  setup_in_progress_ = setup_in_progress;
+  startup_controller_.set_setup_in_progress(setup_in_progress);
   if (!setup_in_progress && sync_initialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 bool ProfileSyncService::sync_initialized() const {
   return backend_initialized_;
 }
 
 bool ProfileSyncService::waiting_for_auth() const {
@@ skipping 189 matching lines @@
     data_type_manager_->Configure(priority_types, reason);
   }
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   // Don't configure datatypes if the setup UI is still on the screen - this
   // is to help multi-screen setting UIs (like iOS) where they don't want to
   // start syncing data until the user is done configuring encryption options,
   // etc. ReconfigureDatatypeManager() will get called again once the UI calls
   // SetSetupInProgress(false).
-  if (setup_in_progress_)
+  if (startup_controller_.setup_in_progress())
     return;
 
   bool restart = false;
   if (!data_type_manager_) {
     restart = true;
     data_type_manager_.reset(
         factory_->CreateDataTypeManager(debug_info_listener_,
                                         &data_type_controllers_,
                                         this,
                                         backend_.get(),
@@ skipping 283 matching lines @@
   // initialized.  In this case, we default to the sensitive types.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   NotifyObservers();
   if (is_sync_managed) {
     DisableForUser();
   } else {
     // Sync is no longer disabled by policy. Try starting it up if appropriate.
-    TryStart();
+    startup_controller_.TryStart();
   }
 }
 
 void ProfileSyncService::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL: {
       const GoogleServiceSigninSuccessDetails* successful =
           content::Details<const GoogleServiceSigninSuccessDetails>(
@@ skipping 92 matching lines @@
 void ProfileSyncService::UnsuppressAndStart() {
   DCHECK(profile_);
   sync_prefs_.SetStartSuppressed(false);
   // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
   // is never called for some clients.
   if (signin_.get() &&
       signin_->GetOriginal()->GetAuthenticatedUsername().empty()) {
     signin_->GetOriginal()->SetAuthenticatedUsername(
         sync_prefs_.GetGoogleServicesUsername());
   }
-  TryStart();
+  startup_controller_.TryStart();
 }
 
 void ProfileSyncService::AcknowledgeSyncedTypes() {
   sync_prefs_.AcknowledgeSyncedTypes(GetRegisteredDataTypes());
 }
 
 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_) {
@@ skipping 57 matching lines @@
   status.last_get_token_error = last_get_token_error_;
   if (request_access_token_retry_timer_.IsRunning())
     status.next_token_request_time = next_token_request_time_;
   return status;
 }
 
 void ProfileSyncService::OverrideNetworkResourcesForTest(
     scoped_ptr<syncer::NetworkResources> network_resources) {
   network_resources_ = network_resources.Pass();
 }