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

components/sync_driver/startup_controller.cc

 // Copyright 2014 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/sync_driver/startup_controller.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 21 matching lines @@
   // No data type requested sync to start and our fallback timer expired.
   TRIGGER_FALLBACK_TIMER,
   MAX_TRIGGER_VALUE
 };
 
 }  // namespace
 
 StartupController::StartupController(const sync_driver::SyncPrefs* sync_prefs,
                                      base::Callback<bool()> can_start,
                                      base::Closure start_backend)
-    : received_start_request_(false),
+    : bypass_setup_complete_(false),
+      received_start_request_(false),
       setup_in_progress_(false),
       sync_prefs_(sync_prefs),
       can_start_(can_start),
       start_backend_(start_backend),
       fallback_timeout_(
           base::TimeDelta::FromSeconds(kDeferredInitFallbackSeconds)),
       weak_factory_(this) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSyncDeferredStartupTimeoutSeconds)) {
     int timeout = kDeferredInitFallbackSeconds;
     if (base::StringToInt(
             base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
                 switches::kSyncDeferredStartupTimeoutSeconds),
             &timeout)) {
       DCHECK_GE(timeout, 0);
       DVLOG(2) << "Sync StartupController overriding startup timeout to "
                << timeout << " seconds.";
       fallback_timeout_ = base::TimeDelta::FromSeconds(timeout);
     }
   }
 }
 
 StartupController::~StartupController() {}
 
 void StartupController::Reset(const syncer::ModelTypeSet registered_types) {
   received_start_request_ = false;
+  bypass_setup_complete_ = false;
   start_up_time_ = base::Time();
   start_backend_time_ = base::Time();
   // Don't let previous timers affect us post-reset.
   weak_factory_.InvalidateWeakPtrs();
   registered_types_ = registered_types;
 }
 
 void StartupController::SetSetupInProgress(bool setup_in_progress) {
   setup_in_progress_ = setup_in_progress;
   if (setup_in_progress_) {
@@ skipping 35 matching lines @@
 }
 
 bool StartupController::TryStart() {
   if (!can_start_.Run())
     return false;
 
   // For performance reasons, defer the heavy lifting for sync init unless:
   //
   // - a datatype has requested an immediate start of sync, or
   // - sync needs to start up the backend immediately to provide control state
-  //   and encryption information to the UI, or
-  // - this is the first time sync is ever starting up.
-  if (received_start_request_ || setup_in_progress_ ||
-      !sync_prefs_->IsFirstSetupComplete()) {
+  //   and encryption information to the UI.
+  // Do not start up the sync backend if setup has not completed and isn't
+  // in progress, unless told to otherwise.
+  if (setup_in_progress_) {
     return StartUp(STARTUP_IMMEDIATE);
+  } else if (sync_prefs_->IsFirstSetupComplete() || bypass_setup_complete_) {
+    return StartUp(received_start_request_ ? STARTUP_IMMEDIATE
+                                           : STARTUP_BACKEND_DEFERRED);
   } else {
-    return StartUp(STARTUP_BACKEND_DEFERRED);
+    return false;
   }
 }
 
+bool StartupController::TryStartImmediately() {
+  received_start_request_ = true;
+  bypass_setup_complete_ = true;
+  return TryStart();
+}
+
 void StartupController::RecordTimeDeferred() {
   DCHECK(!start_up_time_.is_null());
   base::TimeDelta time_deferred = base::Time::Now() - start_up_time_;
   UMA_HISTOGRAM_CUSTOM_TIMES("Sync.Startup.TimeDeferred2",
       time_deferred,
       base::TimeDelta::FromSeconds(0),
       base::TimeDelta::FromMinutes(2),
       60);
 }
 
@@ skipping 45 matching lines @@
                               syncer::MODEL_TYPE_COUNT);
     UMA_HISTOGRAM_ENUMERATION("Sync.Startup.DeferredInitTrigger",
                               TRIGGER_DATA_TYPE_REQUEST,
                               MAX_TRIGGER_VALUE);
   }
   received_start_request_ = true;
   TryStart();
 }
 
 }  // namespace browser_sync