[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 58 matching lines @@
   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_) {
-    TryStart();
+    TryStart(false);
   }
 }
 
 bool StartupController::StartUp(StartUpDeferredOption deferred_option) {
   const bool first_start = start_up_time_.is_null();
   if (first_start)
     start_up_time_ = base::Time::Now();
 
   if (deferred_option == STARTUP_BACKEND_DEFERRED &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 16 matching lines @@
   }
 
   return true;
 }
 
 void StartupController::OverrideFallbackTimeoutForTest(
     const base::TimeDelta& timeout) {
   fallback_timeout_ = timeout;
 }
 
-bool StartupController::TryStart() {
+bool StartupController::TryStart(bool request_immediate) {
+  if (request_immediate)
+    received_start_request_ = true;
+
   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.
+  if (setup_in_progress_) {
     return StartUp(STARTUP_IMMEDIATE);
+  } else if (sync_prefs_->IsFirstSetupComplete()) {
+    if (received_start_request_)
+      return StartUp(STARTUP_IMMEDIATE);
+    else

[maxbogue, 2016/07/15 21:44:48]

nit: this is somewhat personal style but I very much prefer brackets with a
complex if statement (has an else clause, etc).

[Nicolas Zea, 2016/07/15 22:42:22]

Consistency within the file is important in this case. That said, I've replaced
this with a ternary instead.

+      return StartUp(STARTUP_BACKEND_DEFERRED);
   } else {
-    return StartUp(STARTUP_BACKEND_DEFERRED);
+    return false;
   }
 }
 
 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);
 }
 
 void StartupController::OnFallbackStartupTimerExpired() {
   DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSyncDisableDeferredStartup));
 
   if (!start_backend_time_.is_null())
     return;
 
   DVLOG(2) << "Sync deferred init fallback timer expired, starting backend.";
   RecordTimeDeferred();
   UMA_HISTOGRAM_ENUMERATION("Sync.Startup.DeferredInitTrigger",
                             TRIGGER_FALLBACK_TIMER,
                             MAX_TRIGGER_VALUE);
   received_start_request_ = true;
-  TryStart();
+  TryStart(false);
 }
 
 std::string StartupController::GetBackendInitializationStateString() const {
   if (!start_backend_time_.is_null())
     return "Started";
   else if (!start_up_time_.is_null())
     return "Deferred";
   else
     return "Not started";
 }
@@ skipping 17 matching lines @@
   if (!start_up_time_.is_null()) {
     RecordTimeDeferred();
     UMA_HISTOGRAM_ENUMERATION("Sync.Startup.TypeTriggeringInit",
                               ModelTypeToHistogramInt(type),
                               syncer::MODEL_TYPE_COUNT);
     UMA_HISTOGRAM_ENUMERATION("Sync.Startup.DeferredInitTrigger",
                               TRIGGER_DATA_TYPE_REQUEST,
                               MAX_TRIGGER_VALUE);
   }
   received_start_request_ = true;
-  TryStart();
+  TryStart(false);
 }
 
 }  // namespace browser_sync