sync: preliminary support for deferred SyncBackendHost 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 279 matching lines @@
       !(!auto_start_enabled_ && token_service->TokensLoadedFromDB())) {
     return;
   }
 
   // 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.
-  if (!HasSyncSetupCompleted() && !setup_in_progress_ && !auto_start_enabled_)
-    return;
-
-  // All systems Go for launch.
-  StartUp();
+  //
+  // 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()) {
+    StartUp(STARTUP_BACKEND_DEFERRED);
+  } 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_.get())
     backend_->StartSyncingWithServer();
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   registrar_.Add(this,
@@ skipping 145 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() {
+void ProfileSyncService::StartUp(StartUpDeferredOption deferred_option) {
   // Don't start up multiple times.
   if (backend_.get()) {
     DVLOG(1) << "Skipping bringing up backend host.";
     return;
   }
 
   DCHECK(IsSyncEnabledAndLoggedIn());
 
   last_synced_time_ = sync_prefs_.GetLastSyncedTime();
   start_up_time_ = base::Time::Now();

[Nicolas Zea, 2013/02/25 21:12:04]

I'm a bit concerned about the possibility of TryStart being called multiple
times, and therefore start_up_time_ being set more than once, messing up the
histogram. Perhaps condition this on start_up_time_.is_null(). Feel free to
leave it if you're confident this can't be hit more than once.

 
 #if defined(OS_CHROMEOS)
   std::string bootstrap_token = sync_prefs_.GetEncryptionBootstrapToken();
   if (bootstrap_token.empty()) {
     sync_prefs_.SetEncryptionBootstrapToken(
         sync_prefs_.GetSpareBootstrapToken());
   }
 #endif
+
+  if (!sync_global_error_.get()) {
+#if !defined(OS_ANDROID)
+    sync_global_error_.reset(new SyncGlobalError(this, signin()));
+#endif
+    GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
+        sync_global_error_.get());
+    AddObserver(sync_global_error_.get());
+  }
+
+  if (deferred_option == STARTUP_BACKEND_DEFERRED &&
+      CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kSyncEnableDeferredStartup)) {
+    return;
+  }
+  DCHECK_EQ(STARTUP_IMMEDIATE, deferred_option);
+  StartUpSlowBackendComponents(STARTUP_IMMEDIATE);
+}
+
+void ProfileSyncService::StartUpSlowBackendComponents(
+    StartUpDeferredOption deferred_option) {
+  // Don't start up multiple times.
+  if (backend_.get()) {
+    DVLOG(1) << "Skipping bringing up backend host.";
+    return;
+  }
+
+  DCHECK(!start_up_time_.is_null());
+  if (deferred_option == STARTUP_BACKEND_DEFERRED) {
+    base::TimeDelta time_deferred = base::Time::Now() - start_up_time_;
+    UMA_HISTOGRAM_TIMES("Sync.Startup.TimeDeferred", time_deferred);
+  }
+
+  DCHECK(IsSyncEnabledAndLoggedIn());
   CreateBackend();
 
   // 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());
 
   // |backend_| may end up being NULL here in tests (in synchronous
   // initialization mode).
   //
   // TODO(akalin): Fix this horribly non-intuitive behavior (see
   // http://crbug.com/140354).
   if (backend_.get()) {
     backend_->UpdateRegisteredInvalidationIds(
         invalidator_registrar_->GetAllRegisteredIds());
   }
-
-  if (!sync_global_error_.get()) {
-#if !defined(OS_ANDROID)
-    sync_global_error_.reset(new SyncGlobalError(this, signin()));
-#endif
-    GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
-        sync_global_error_.get());
-    AddObserver(sync_global_error_.get());
-  }
 }
 
 void ProfileSyncService::RegisterInvalidationHandler(
     syncer::InvalidationHandler* handler) {
   invalidator_registrar_->RegisterHandler(handler);
 }
 
 void ProfileSyncService::UpdateRegisteredInvalidationIds(
     syncer::InvalidationHandler* handler,
     const syncer::ObjectIdSet& ids) {
@@ skipping 708 matching lines @@
              data_type_manager_.get() &&
              data_type_manager_->state() != DataTypeManager::CONFIGURED) {
     return "Datatypes not fully initialized";
   } else if (ShouldPushChanges()) {
     return "Sync service initialized";
   } else {
     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";
+}
+
 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;
@@ skipping 721 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }