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

components/sync_driver/startup_controller_unittest.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/message_loop/message_loop.h"
@@ skipping 68 matching lines @@
 
  private:
   bool can_start_;
   bool started_;
   base::MessageLoop message_loop_;
   syncable_prefs::TestingPrefServiceSyncable pref_service_;
   std::unique_ptr<sync_driver::SyncPrefs> sync_prefs_;
   std::unique_ptr<StartupController> controller_;
 };
 
-// Test that sync doesn't start until all conditions are met.
-TEST_F(StartupControllerTest, Basic) {
-  controller()->TryStart();
+// Test that sync doesn't start if setup is not in progress or complete.
+TEST_F(StartupControllerTest, NoSetupComplete) {
+  controller()->TryStart(false);
   ExpectNotStarted();
 
   SetCanStart(true);
-  controller()->TryStart();
-  ExpectStarted();
+  controller()->TryStart(false);
+  ExpectNotStarted();
 }
 
 // Test that sync defers if first setup is complete.
 TEST_F(StartupControllerTest, DefersAfterFirstSetupComplete) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectStartDeferred();
 }
 
 // Test that a data type triggering startup starts sync immediately.
 TEST_F(StartupControllerTest, NoDeferralDataTypeTrigger) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
   controller()->OnDataTypeRequestsSyncStartup(syncer::SESSIONS);
   ExpectStarted();
 }
 
 // Test that a data type trigger interrupts the deferral timer and starts
 // sync immediately.
 TEST_F(StartupControllerTest, DataTypeTriggerInterruptsDeferral) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectStartDeferred();
 
   controller()->OnDataTypeRequestsSyncStartup(syncer::SESSIONS);
   ExpectStarted();
 
   // The fallback timer shouldn't result in another invocation of the closure
   // we passed to the StartupController.
   clear_started();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(started());
 }
 
 // Test that the fallback timer starts sync in the event all
 // conditions are met and no data type requests sync.
 TEST_F(StartupControllerTest, FallbackTimer) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectStartDeferred();
 
   base::RunLoop().RunUntilIdle();
   ExpectStarted();
 }
 
 // Test that we start immediately if sessions is disabled.
 TEST_F(StartupControllerTest, NoDeferralWithoutSessionsSync) {
   syncer::ModelTypeSet types(syncer::UserTypes());
   // Disabling sessions means disabling 4 types due to groupings.
   types.Remove(syncer::SESSIONS);
   types.Remove(syncer::PROXY_TABS);
   types.Remove(syncer::TYPED_URLS);
   types.Remove(syncer::SUPERVISED_USER_SETTINGS);
   sync_prefs()->SetKeepEverythingSynced(false);
   sync_prefs()->SetPreferredDataTypes(syncer::UserTypes(), types);
   controller()->Reset(syncer::UserTypes());
 
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectStarted();
 }
 
 // Sanity check that the fallback timer doesn't fire before startup
 // conditions are met.
 TEST_F(StartupControllerTest, FallbackTimerWaits) {
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectNotStarted();
   base::RunLoop().RunUntilIdle();
   ExpectNotStarted();
 }
 
 // Test that sync starts immediately when setup in progress is true.
 TEST_F(StartupControllerTest, NoDeferralSetupInProgressTrigger) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
   controller()->SetSetupInProgress(true);
   ExpectStarted();
 }
 
 // Test that setup in progress being set to true interrupts the deferral timer
 // and starts sync immediately.
 TEST_F(StartupControllerTest, SetupInProgressTriggerInterruptsDeferral) {
   sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(false);
   ExpectStartDeferred();
 
   controller()->SetSetupInProgress(true);
   ExpectStarted();
 }
 
-// Test that start isn't deferred on the first start but is on restarts.
-TEST_F(StartupControllerTest, DeferralOnRestart) {
+// Test that immediate startup can be forced.
+TEST_F(StartupControllerTest, ForceImmediateStartup) {
+  sync_prefs()->SetFirstSetupComplete();
   SetCanStart(true);
-  controller()->TryStart();
+  controller()->TryStart(true);
   ExpectStarted();
-
-  clear_started();
-  controller()->Reset(syncer::UserTypes());
-  ExpectNotStarted();
-  controller()->TryStart();
-  ExpectStartDeferred();
 }
 
 // Test that setup-in-progress tracking is persistent across a Reset.
 TEST_F(StartupControllerTest, ResetDuringSetup) {
   SetCanStart(true);
 
   // Simulate UI telling us setup is in progress.
   controller()->SetSetupInProgress(true);
 
   // This could happen if the UI triggers a stop-syncing permanently call.
   controller()->Reset(syncer::UserTypes());
 
   // From the UI's point of view, setup is still in progress.
   EXPECT_TRUE(controller()->IsSetupInProgress());
 }
 
 }  // namespace browser_sync