sync: SyncableService support for starting sync

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 122 matching lines @@
                                        SigninManagerBase* signin_manager,
                                        StartBehavior start_behavior)
     : last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       // |profile| may be NULL in unit tests.
       sync_prefs_(profile_ ? profile_->GetPrefs() : NULL),
       invalidator_storage_(profile_ ? profile_->GetPrefs(): NULL),
       sync_service_url_(kDevServerUrl),
+      data_type_requested_sync_startup_(false),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       signin_(signin_manager),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_(false),
       encryption_pending_(false),
@@ skipping 145 matching lines @@
   // 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()) {
-    StartUp(STARTUP_BACKEND_DEFERRED);
+    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_.get())
     backend_->StartSyncingWithServer();
@@ skipping 201 matching lines @@
         sync_global_error_.get());
     AddObserver(sync_global_error_.get());
   }
 
   if (deferred_option == STARTUP_BACKEND_DEFERRED &&
       CommandLine::ForCurrentProcess()->
           HasSwitch(switches::kSyncEnableDeferredStartup)) {
     return;
   }
 
-  StartUpSlowBackendComponents(STARTUP_IMMEDIATE);
+  StartUpSlowBackendComponents();
 }
 
-void ProfileSyncService::StartUpSlowBackendComponents(
-    StartUpDeferredOption deferred_option) {
+void ProfileSyncService::OnDataTypeRequestsSyncStartup(
+    syncer::ModelType type) {
+  DCHECK(syncer::UserTypes().Has(type));

[haitaol1, 2013/04/25 19:18:18]

Should you check whether sync for this type is enabled?

[tim (not reviewing), 2013/05/01 21:19:47]

Good catch. A disabled type shouldn't trigger sync to start (it wouldn't cause
sync for *that* type to start, but seems wrong nonetheless).

+  if (backend_.get()) {
+    DVLOG(1) << "A data type requested sync startup, but it looks like "
+                "something else beat it to the punch.";
+    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",
+                                type,
+                                syncer::MODEL_TYPE_COUNT);
+    }
+    data_type_requested_sync_startup_ = true;
+    TryStart();
+  }
+  DVLOG(2) << "Ignoring data type request for sync startup: "
+           << syncer::ModelTypeToString(type);
+}
+
+void ProfileSyncService::StartUpSlowBackendComponents() {
   // 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).
@@ skipping 1507 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);
 }