sync: reland deferred init

chrome/browser/sync/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 "chrome/browser/sync/startup_controller.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/managed_mode/managed_user_signin_manager_wrapper.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/common/chrome_switches.h"
 
 namespace browser_sync {
 
 namespace {
 
 // The amount of time we'll wait to initialize sync if no data type triggers
@@ skipping 19 matching lines @@
     const browser_sync::SyncPrefs* sync_prefs,
     const ManagedUserSigninManagerWrapper* signin,
     base::Closure start_backend)
     : received_start_request_(false),
       setup_in_progress_(false),
       auto_start_enabled_(start_behavior == AUTO_START),
       sync_prefs_(sync_prefs),
       token_service_(token_service),
       signin_(signin),
       start_backend_(start_backend),
-      fallback_timeout_(
-          base::TimeDelta::FromSeconds(kDeferredInitFallbackSeconds)),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+
+  int timeout = kDeferredInitFallbackSeconds;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSyncDeferredStartupTimeoutSeconds)) {
+    base::StringToInt(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(

[rlarocque, 2014/03/07 20:00:27]

Could you check the return value?  And maybe sanity-check the value you get
back, too?  (eg. fail if the value is negative)

+        switches::kSyncDeferredStartupTimeoutSeconds), &timeout);
+  }
+
+  fallback_timeout_ = base::TimeDelta::FromSeconds(timeout);
+}
 
 StartupController::~StartupController() {}
 
 void StartupController::Reset(const syncer::ModelTypeSet registered_types) {
   received_start_request_ = false;
   setup_in_progress_ = 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::set_setup_in_progress(bool in_progress) {
   setup_in_progress_ = in_progress;
 }
 
 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 &&
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSyncEnableDeferredStartup) &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSyncDisableDeferredStartup) &&
       sync_prefs_->GetPreferredDataTypes(registered_types_)
           .Has(syncer::SESSIONS)) {
     if (first_start) {
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&StartupController::OnFallbackStartupTimerExpired,
                      weak_factory_.GetWeakPtr()), fallback_timeout_);
     }
     return false;
   }
@@ skipping 58 matching lines @@
   } 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.
     return StartUp(STARTUP_IMMEDIATE);
   }
 
   return false;
 }
 
 void StartupController::OnFallbackStartupTimerExpired() {
-  DCHECK(CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSyncEnableDeferredStartup));
+  DCHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSyncDisableDeferredStartup));
 
   if (!start_backend_time_.is_null())
     return;
 
   DVLOG(2) << "Sync deferred init fallback timer expired, starting backend.";
   DCHECK(!start_up_time_.is_null());
   base::TimeDelta time_deferred = base::Time::Now() - start_up_time_;
   UMA_HISTOGRAM_TIMES("Sync.Startup.TimeDeferred", time_deferred);
   UMA_HISTOGRAM_ENUMERATION("Sync.Startup.DeferredInitTrigger",
                             TRIGGER_FALLBACK_TIMER,
                             MAX_TRIGGER_VALUE);
   received_start_request_ = true;
   TryStart();
 }
 
 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";
 }
 
 void StartupController::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSyncEnableDeferredStartup)) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSyncDisableDeferredStartup)) {
     DVLOG(2) << "Ignoring data type request for sync startup: "
              << syncer::ModelTypeToString(type);
     return;
   }
 
   if (!start_backend_time_.is_null())
     return;
 
   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()) {
     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);
     UMA_HISTOGRAM_ENUMERATION("Sync.Startup.DeferredInitTrigger",
                               TRIGGER_DATA_TYPE_REQUEST,
                               MAX_TRIGGER_VALUE);
   }
   received_start_request_ = true;
   TryStart();
 }
 
 }  // namespace browser_sync