Remove initial_sync_ended bits

chrome/browser/sync/glue/sync_backend_host_unittest.cc

 // Copyright (c) 2012 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/glue/sync_backend_host.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 167 matching lines @@
     profile_.reset();
     // Pump messages posted by the sync thread (which may end up
     // posting on the IO thread).
     ui_loop_.RunUntilIdle();
     io_thread_.Stop();
     // Pump any messages posted by the IO thread.
     ui_loop_.RunUntilIdle();
   }
 
   // Synchronously initializes the backend.
-  void InitializeBackend() {
-    EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, true)).
+  void InitializeBackend(bool expect_success) {
+    EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, expect_success)).
         WillOnce(InvokeWithoutArgs(QuitMessageLoop));
     backend_->Initialize(&mock_frontend_,
                          syncer::WeakHandle<syncer::JsEventHandler>(),
                          GURL(""),
                          credentials_,
                          true,
                          &fake_manager_factory_,
                          &handler_,
                          NULL);
     ui_loop_.PostDelayedTask(FROM_HERE,
@@ skipping 43 matching lines @@
   scoped_ptr<InvalidatorStorage> invalidator_storage_;
   scoped_ptr<SyncBackendHost> backend_;
   FakeSyncManager* fake_manager_;
   FakeSyncManagerFactory fake_manager_factory_;
   syncer::ModelTypeSet enabled_types_;
 };
 
 // Test basic initialization with no initial types (first time initialization).
 // Only the nigori should be configured.
 TEST_F(SyncBackendHostTest, InitShutdown) {
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       syncer::ControlTypes()).Empty());
 }
 
 // Test first time sync scenario. All types should be properly configured.
 TEST_F(SyncBackendHostTest, FirstTimeSync) {
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       syncer::ControlTypes()).Empty());
 
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // Test the restart after setting up sync scenario. No enabled types should be
 // downloaded or cleaned.
 TEST_F(SyncBackendHostTest, Restart) {
   sync_prefs_->SetSyncSetupCompleted();
   syncer::ModelTypeSet all_but_nigori = enabled_types_;
   fake_manager_factory_.set_progress_marker_types(enabled_types_);
   fake_manager_factory_.set_initial_sync_ended_types(enabled_types_);
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
@@ skipping 13 matching lines @@
   // Set sync manager behavior before passing it down. All types have progress
   // markers, but nigori and bookmarks are missing initial sync ended.
   syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS);
   syncer::ModelTypeSet full_types =
       Difference(enabled_types_, partial_types);
   fake_manager_factory_.set_progress_marker_types(enabled_types_);
   fake_manager_factory_.set_initial_sync_ended_types(full_types);
 
   // Bringing up the backend should purge all partial types, then proceed to
   // download the Nigori.
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ModelTypeSet(syncer::NIGORI)));
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(
           Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI))));
 
   // Now do the actual configuration, which should download and apply bookmarks.
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // Test the behavior when we lose the sync db. Although we already have types
 // enabled, we should re-download all of them because we lost their data.
 TEST_F(SyncBackendHostTest, LostDB) {
   sync_prefs_->SetSyncSetupCompleted();
   // Initialization should fetch the Nigori node.  Everything else should be
   // left untouched.
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ModelTypeSet(syncer::ControlTypes())));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::ModelTypeSet(syncer::ControlTypes())));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(
           Difference(enabled_types_, syncer::ControlTypes())));
 
   // The database was empty, so any cleaning is entirely optional.  We want to
   // reset this value before running the next part of the test, though.
   fake_manager_->GetAndResetCleanedTypes();
 
   // The actual configuration should redownload and apply all the enabled types.
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 TEST_F(SyncBackendHostTest, DisableTypes) {
   // Simulate first time sync.
-  InitializeBackend();
+  InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
@@ skipping 14 matching lines @@
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            old_types).Equals(disabled_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 TEST_F(SyncBackendHostTest, AddTypes) {
   // Simulate first time sync.
-  InitializeBackend();
+  InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
@@ skipping 15 matching lines @@
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // And and disable in the same configuration.
 TEST_F(SyncBackendHostTest, AddDisableTypes) {
   // Simulate first time sync.
-  InitializeBackend();
+  InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
@@ skipping 30 matching lines @@
   // Set sync manager behavior before passing it down. All types have progress
   // markers and initial sync ended except the new types.
   syncer::ModelTypeSet old_types = enabled_types_;
   fake_manager_factory_.set_progress_marker_types(old_types);
   fake_manager_factory_.set_initial_sync_ended_types(old_types);
   syncer::ModelTypeSet new_types(syncer::APP_SETTINGS,
                                  syncer::EXTENSION_SETTINGS);
   enabled_types_.PutAll(new_types);
 
   // Does nothing.
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            old_types).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(old_types));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(new_types));
 
   // Downloads and applies the new types.
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
@@ skipping 20 matching lines @@
   syncer::ModelTypeSet full_types =
       Difference(enabled_types_, partial_types);
   fake_manager_factory_.set_progress_marker_types(old_types);
   fake_manager_factory_.set_initial_sync_ended_types(full_types);
   syncer::ModelTypeSet new_types(syncer::APP_SETTINGS,
                                  syncer::EXTENSION_SETTINGS);
   enabled_types_.PutAll(new_types);
 
   // Purge the partial types.  The nigori will be among the purged types, but
   // the syncer will re-download it by the time the initialization is complete.
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ModelTypeSet(syncer::NIGORI)));
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(Union(new_types, Difference(
                       partial_types, syncer::ModelTypeSet(syncer::NIGORI)))));
 
   // Downloads and applies the new types and partial types (which includes
   // nigori anyways).
   ConfigureDataTypes(enabled_types_,
                      Difference(syncer::ModelTypeSet::All(),
                                 enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       Union(new_types, partial_types)));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // Register for some IDs and trigger an invalidation.  This should
 // propagate all the way to the frontend.
 TEST_F(SyncBackendHostTest, Invalidate) {
-  InitializeBackend();
+  InitializeBackend(true);
 
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(1, "id1"));
   ids.insert(invalidation::ObjectId(2, "id2"));
   const syncer::ObjectIdInvalidationMap& invalidation_map =
       syncer::ObjectIdSetToInvalidationMap(ids, "payload");
 
   EXPECT_CALL(
       mock_frontend_,
       OnIncomingInvalidation(invalidation_map, syncer::REMOTE_INVALIDATION))
       .WillOnce(InvokeWithoutArgs(QuitMessageLoop));
 
   backend_->UpdateRegisteredInvalidationIds(ids);
   fake_manager_->Invalidate(invalidation_map, syncer::REMOTE_INVALIDATION);
   ui_loop_.PostDelayedTask(
       FROM_HERE, ui_loop_.QuitClosure(), TestTimeouts::action_timeout());
   ui_loop_.Run();
 }
 
 // Register for some IDs and update the invalidator state.  This
 // should propagate all the way to the frontend.
 TEST_F(SyncBackendHostTest, UpdateInvalidatorState) {
-  InitializeBackend();
+  InitializeBackend(true);
 
   EXPECT_CALL(mock_frontend_,
               OnInvalidatorStateChange(syncer::INVALIDATIONS_ENABLED))
       .WillOnce(InvokeWithoutArgs(QuitMessageLoop));
 
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(3, "id3"));
   backend_->UpdateRegisteredInvalidationIds(ids);
   fake_manager_->UpdateInvalidatorState(syncer::INVALIDATIONS_ENABLED);
   ui_loop_.PostDelayedTask(
       FROM_HERE, ui_loop_.QuitClosure(), TestTimeouts::action_timeout());
   ui_loop_.Run();
 }
 
 // Call StopSyncingForShutdown() on the backend and fire some invalidations
 // before calling Shutdown().  Then start up and shut down the backend again.
 // Those notifications shouldn't propagate to the frontend.
 TEST_F(SyncBackendHostTest, InvalidationsAfterStopSyncingForShutdown) {
-  InitializeBackend();
+  InitializeBackend(true);
 
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(5, "id5"));
   backend_->UpdateRegisteredInvalidationIds(ids);
 
   backend_->StopSyncingForShutdown();
 
   // Should not trigger anything.
   fake_manager_->UpdateInvalidatorState(syncer::TRANSIENT_INVALIDATION_ERROR);
   fake_manager_->UpdateInvalidatorState(syncer::INVALIDATIONS_ENABLED);
   const syncer::ObjectIdInvalidationMap& invalidation_map =
       syncer::ObjectIdSetToInvalidationMap(ids, "payload");
   fake_manager_->Invalidate(invalidation_map, syncer::REMOTE_INVALIDATION);
 
   // Make sure the above calls take effect before we continue.
   fake_manager_->WaitForSyncThread();
 
   backend_->Shutdown(false);
   backend_.reset();
 
   TearDown();
   SetUp();
 }
 
 // Ensure the device info tracker is initialized properly on startup.
 TEST_F(SyncBackendHostTest, InitializeDeviceInfo) {
   ASSERT_EQ(NULL, backend_->GetSyncedDeviceTracker());
 
-  InitializeBackend();
+  InitializeBackend(true);
   const SyncedDeviceTracker* device_tracker =
       backend_->GetSyncedDeviceTracker();
   ASSERT_TRUE(device_tracker->ReadLocalDeviceInfo());
 }
 
 // Verify that downloading control types only downloads those types that do
 // not have initial sync ended set.
 TEST_F(SyncBackendHostTest, DownloadControlTypes) {
   sync_prefs_->SetSyncSetupCompleted();
   // Set sync manager behavior before passing it down. Experiments and device
   // info are new types without progress markers or initial sync ended, while
   // all other types have been fully downloaded and applied.
   syncer::ModelTypeSet new_types(syncer::EXPERIMENTS, syncer::DEVICE_INFO);
   syncer::ModelTypeSet old_types =
       Difference(enabled_types_, new_types);
   fake_manager_factory_.set_progress_marker_types(old_types);
   fake_manager_factory_.set_initial_sync_ended_types(old_types);
 
   // Bringing up the backend should download the new types without downloading
   // any old types.
-  InitializeBackend();
+  InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
+// Fail to download control types.  It's believed that there is a server bug
+// which can allow this to happen (crbug.com/164288).  The sync backend host
+// should detect this condition and fail to initialize the backend.
+//
+// The failure is "silent" in the sense that the GetUpdates request appears to
+// be successful, but it returned no results.  This means that the usual
+// download retry logic will not be invoked.
+TEST_F(SyncBackendHostTest, SilentlyFailToDownloadControlTypes) {
+  fake_manager_factory_.set_configure_fail_types(syncer::ModelTypeSet::All());
+  InitializeBackend(false);
+}
+
 }  // namespace
 
 }  // namespace browser_sync