[Sync] Inject startup dependencies into StartupController.

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"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
-#include "components/signin/core/browser/profile_oauth2_token_service.h"
-#include "components/sync_driver/signin_manager_wrapper.h"
 #include "components/sync_driver/sync_driver_switches.h"
 #include "components/sync_driver/sync_prefs.h"
 
 namespace browser_sync {
 
 namespace {
 
 // The amount of time we'll wait to initialize sync if no data type triggers
 // initialization via a StartSyncFlare.
 const int kDeferredInitFallbackSeconds = 10;
 
 // Enum (for UMA, primarily) defining different events that cause us to
 // exit the "deferred" state of initialization and invoke start_backend.
 enum DeferredInitTrigger {
   // We have received a signal from a SyncableService requesting that sync
   // starts as soon as possible.
   TRIGGER_DATA_TYPE_REQUEST,
   // No data type requested sync to start and our fallback timer expired.
   TRIGGER_FALLBACK_TIMER,
   MAX_TRIGGER_VALUE
 };
 
 }  // namespace
 
-StartupController::StartupController(
-    const ProfileOAuth2TokenService* token_service,
-    const sync_driver::SyncPrefs* sync_prefs,
-    const SigninManagerWrapper* signin,
-    base::Closure start_backend)
+StartupController::StartupController(const sync_driver::SyncPrefs* sync_prefs,
+                                     base::Callback<bool()> can_start,
+                                     base::Closure start_backend)
     : received_start_request_(false),
       setup_in_progress_(false),
       sync_prefs_(sync_prefs),
-      token_service_(token_service),
-      signin_(signin),
+      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),
@@ skipping 51 matching lines @@
 
   return true;
 }
 
 void StartupController::OverrideFallbackTimeoutForTest(
     const base::TimeDelta& timeout) {
   fallback_timeout_ = timeout;
 }
 
 bool StartupController::TryStart() {
-  if (sync_prefs_->IsManaged())
+  if (!can_start_.Run())
     return false;
 
-  if (!sync_prefs_->IsSyncRequested())
-    return false;
-
-  if (signin_->GetAccountIdToUse().empty())
-    return false;
-
-  if (!token_service_)
-    return false;
-
-  if (!token_service_->RefreshTokenIsAvailable(signin_->GetAccountIdToUse())) {
-    return false;
-  }
-
-  // TODO(tim): Seems wrong to always record this histogram here...
-  // If we got here then tokens are loaded and user logged in and sync is
-  // enabled. If OAuth refresh token is not available then something is wrong.
-  // When PSS requests access token, OAuth2TokenService will return error and
-  // PSS will show error to user asking to reauthenticate.
-  UMA_HISTOGRAM_BOOLEAN("Sync.RefreshTokenAvailable", true);
-
   // 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()) {
     return StartUp(STARTUP_IMMEDIATE);
   } else {
@@ skipping 59 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