src/chrome/browser/sync/glue/sync_backend_host_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/sync/glue/sync_backend_host.h"
   6
   7 #include <cstddef>
   8
   9 #include "base/location.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/synchronization/waitable_event.h"
  13 #include "base/test/test_timeouts.h"
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #include "chrome/browser/invalidation/invalidator_storage.h"
  16 #include "chrome/browser/prefs/pref_service_syncable.h"
  17 #include "chrome/browser/sync/glue/device_info.h"
  18 #include "chrome/browser/sync/glue/synced_device_tracker.h"
  19 #include "chrome/browser/sync/sync_prefs.h"
  20 #include "chrome/test/base/testing_profile.h"
  21 #include "components/user_prefs/pref_registry_syncable.h"
  22 #include "content/public/browser/notification_service.h"
  23 #include "content/public/test/test_browser_thread_bundle.h"
  24 #include "content/public/test/test_utils.h"
  25 #include "google/cacheinvalidation/include/types.h"
  26 #include "net/url_request/test_url_fetcher_factory.h"
  27 #include "sync/internal_api/public/base/model_type.h"
  28 #include "sync/internal_api/public/engine/model_safe_worker.h"
  29 #include "sync/internal_api/public/sync_manager_factory.h"
  30 #include "sync/internal_api/public/test/fake_sync_manager.h"
  31 #include "sync/internal_api/public/util/experiments.h"
  32 #include "sync/notifier/invalidator_state.h"
  33 #include "sync/protocol/encryption.pb.h"
  34 #include "sync/protocol/sync_protocol_error.h"
  35 #include "sync/util/test_unrecoverable_error_handler.h"
  36 #include "testing/gmock/include/gmock/gmock.h"
  37 #include "testing/gtest/include/gtest/gtest.h"
  38 #include "url/gurl.h"
  39
  40 using content::BrowserThread;
  41 using syncer::FakeSyncManager;
  42 using syncer::SyncManager;
  43 using ::testing::InvokeWithoutArgs;
  44 using ::testing::StrictMock;
  45 using ::testing::_;
  46
  47 namespace browser_sync {
  48
  49 namespace {
  50
  51 ACTION_P(Signal, event) {
  52   event->Signal();
  53 }
  54
  55 void QuitMessageLoop() {
  56   base::MessageLoop::current()->Quit();
  57 }
  58
  59 class MockSyncFrontend : public SyncFrontend {
  60  public:
  61   virtual ~MockSyncFrontend() {}
  62
  63   MOCK_METHOD1(OnInvalidatorStateChange,
  64                void(syncer::InvalidatorState));
  65   MOCK_METHOD1(OnIncomingInvalidation,
  66                void(const syncer::ObjectIdInvalidationMap&));
  67   MOCK_METHOD3(
  68       OnBackendInitialized,
  69       void(const syncer::WeakHandle<syncer::JsBackend>&,
  70            const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&,
  71            bool));
  72   MOCK_METHOD0(OnSyncCycleCompleted, void());
  73   MOCK_METHOD1(OnConnectionStatusChange,
  74                void(syncer::ConnectionStatus status));
  75   MOCK_METHOD0(OnStopSyncingPermanently, void());
  76   MOCK_METHOD0(OnClearServerDataSucceeded, void());
  77   MOCK_METHOD0(OnClearServerDataFailed, void());
  78   MOCK_METHOD2(OnPassphraseRequired,
  79                void(syncer::PassphraseRequiredReason,
  80                     const sync_pb::EncryptedData&));
  81   MOCK_METHOD0(OnPassphraseAccepted, void());
  82   MOCK_METHOD2(OnEncryptedTypesChanged,
  83                void(syncer::ModelTypeSet, bool));
  84   MOCK_METHOD0(OnEncryptionComplete, void());
  85   MOCK_METHOD1(OnMigrationNeededForTypes, void(syncer::ModelTypeSet));
  86   MOCK_METHOD1(OnExperimentsChanged,
  87       void(const syncer::Experiments&));
  88   MOCK_METHOD1(OnActionableError,
  89       void(const syncer::SyncProtocolError& sync_error));
  90   MOCK_METHOD0(OnSyncConfigureRetry, void());
  91 };
  92
  93 class FakeSyncManagerFactory : public syncer::SyncManagerFactory {
  94  public:
  95   explicit FakeSyncManagerFactory(FakeSyncManager** fake_manager)
  96      : fake_manager_(fake_manager) {
  97     *fake_manager_ = NULL;
  98   }
  99   virtual ~FakeSyncManagerFactory() {}
 100
 101   // SyncManagerFactory implementation.  Called on the sync thread.
 102   virtual scoped_ptr<SyncManager> CreateSyncManager(
 103       std::string name) OVERRIDE {
 104     *fake_manager_ = new FakeSyncManager(initial_sync_ended_types_,
 105                                          progress_marker_types_,
 106                                          configure_fail_types_);
 107     return scoped_ptr<SyncManager>(*fake_manager_);
 108   }
 109
 110   void set_initial_sync_ended_types(syncer::ModelTypeSet types) {
 111     initial_sync_ended_types_ = types;
 112   }
 113
 114   void set_progress_marker_types(syncer::ModelTypeSet types) {
 115     progress_marker_types_ = types;
 116   }
 117
 118   void set_configure_fail_types(syncer::ModelTypeSet types) {
 119     configure_fail_types_ = types;
 120   }
 121
 122  private:
 123   syncer::ModelTypeSet initial_sync_ended_types_;
 124   syncer::ModelTypeSet progress_marker_types_;
 125   syncer::ModelTypeSet configure_fail_types_;
 126   FakeSyncManager** fake_manager_;
 127 };
 128
 129 class SyncBackendHostTest : public testing::Test {
 130  protected:
 131   SyncBackendHostTest()
 132       : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
 133         fake_manager_(NULL) {}
 134
 135   virtual ~SyncBackendHostTest() {}
 136
 137   virtual void SetUp() OVERRIDE {
 138     profile_.reset(new TestingProfile());
 139     sync_prefs_.reset(new SyncPrefs(profile_->GetPrefs()));
 140     backend_.reset(new SyncBackendHost(
 141         profile_->GetDebugName(),
 142         profile_.get(),
 143         sync_prefs_->AsWeakPtr()));
 144     credentials_.email = "user@example.com";
 145     credentials_.sync_token = "sync_token";
 146
 147     fake_manager_factory_.reset(new FakeSyncManagerFactory(&fake_manager_));
 148
 149     // These types are always implicitly enabled.
 150     enabled_types_.PutAll(syncer::ControlTypes());
 151
 152     // NOTE: We can't include Passwords or Typed URLs due to the Sync Backend
 153     // Registrar removing them if it can't find their model workers.
 154     enabled_types_.Put(syncer::BOOKMARKS);
 155     enabled_types_.Put(syncer::NIGORI);
 156     enabled_types_.Put(syncer::DEVICE_INFO);
 157     enabled_types_.Put(syncer::PREFERENCES);
 158     enabled_types_.Put(syncer::SESSIONS);
 159     enabled_types_.Put(syncer::SEARCH_ENGINES);
 160     enabled_types_.Put(syncer::AUTOFILL);
 161     enabled_types_.Put(syncer::EXPERIMENTS);
 162   }
 163
 164   virtual void TearDown() OVERRIDE {
 165     if (backend_) {
 166       backend_->StopSyncingForShutdown();
 167       backend_->Shutdown(SyncBackendHost::STOP);
 168     }
 169     backend_.reset();
 170     sync_prefs_.reset();
 171     profile_.reset();
 172     // Pump messages posted by the sync thread (which may end up
 173     // posting on the IO thread).
 174     base::RunLoop().RunUntilIdle();
 175     content::RunAllPendingInMessageLoop(BrowserThread::IO);
 176     // Pump any messages posted by the IO thread.
 177     base::RunLoop().RunUntilIdle();
 178   }
 179
 180   // Synchronously initializes the backend.
 181   void InitializeBackend(bool expect_success) {
 182     EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, expect_success)).
 183         WillOnce(InvokeWithoutArgs(QuitMessageLoop));
 184     backend_->Initialize(
 185         &mock_frontend_,
 186         scoped_ptr<base::Thread>(),
 187         syncer::WeakHandle<syncer::JsEventHandler>(),
 188         GURL(std::string()),
 189         credentials_,
 190         true,
 191         fake_manager_factory_.PassAs<syncer::SyncManagerFactory>(),
 192         scoped_ptr<syncer::UnrecoverableErrorHandler>(
 193             new syncer::TestUnrecoverableErrorHandler).Pass(),
 194         NULL);
 195     base::RunLoop run_loop;
 196     BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
 197                                    run_loop.QuitClosure(),
 198                                    TestTimeouts::action_timeout());
 199     run_loop.Run();
 200     // |fake_manager_factory_|'s fake_manager() is set on the sync
 201     // thread, but we can rely on the message loop barriers to
 202     // guarantee that we see the updated value.
 203     DCHECK(fake_manager_);
 204   }
 205
 206   // Synchronously configures the backend's datatypes.
 207   void ConfigureDataTypes(syncer::ModelTypeSet types_to_add,
 208                           syncer::ModelTypeSet types_to_remove) {
 209     BackendDataTypeConfigurer::DataTypeConfigStateMap config_state_map;
 210     BackendDataTypeConfigurer::SetDataTypesState(
 211         BackendDataTypeConfigurer::CONFIGURE_ACTIVE,
 212         types_to_add,
 213         &config_state_map);
 214     BackendDataTypeConfigurer::SetDataTypesState(
 215         BackendDataTypeConfigurer::DISABLED,
 216         types_to_remove, &config_state_map);
 217
 218     types_to_add.PutAll(syncer::ControlTypes());
 219     backend_->ConfigureDataTypes(
 220         syncer::CONFIGURE_REASON_RECONFIGURATION,
 221         config_state_map,
 222         base::Bind(&SyncBackendHostTest::DownloadReady,
 223                    base::Unretained(this)),
 224         base::Bind(&SyncBackendHostTest::OnDownloadRetry,
 225                    base::Unretained(this)));
 226     base::RunLoop run_loop;
 227     BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
 228                                    run_loop.QuitClosure(),
 229                                    TestTimeouts::action_timeout());
 230     run_loop.Run();
 231   }
 232
 233   void IssueRefreshRequest(syncer::ModelTypeSet types) {
 234     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 235
 236     content::NotificationService::current()->Notify(
 237         chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
 238         content::Source<Profile>(profile_.get()),
 239         content::Details<syncer::ModelTypeSet>(&types));
 240   }
 241
 242  protected:
 243   void DownloadReady(syncer::ModelTypeSet succeeded_types,
 244                      syncer::ModelTypeSet failed_types) {
 245     base::MessageLoop::current()->Quit();
 246   }
 247
 248   void OnDownloadRetry() {
 249     NOTIMPLEMENTED();
 250   }
 251
 252   content::TestBrowserThreadBundle thread_bundle_;
 253   StrictMock<MockSyncFrontend> mock_frontend_;
 254   syncer::SyncCredentials credentials_;
 255   scoped_ptr<TestingProfile> profile_;
 256   scoped_ptr<SyncPrefs> sync_prefs_;
 257   scoped_ptr<SyncBackendHost> backend_;
 258   scoped_ptr<FakeSyncManagerFactory> fake_manager_factory_;
 259   FakeSyncManager* fake_manager_;
 260   syncer::ModelTypeSet enabled_types_;
 261 };
 262
 263 // Test basic initialization with no initial types (first time initialization).
 264 // Only the nigori should be configured.
 265 TEST_F(SyncBackendHostTest, InitShutdown) {
 266   InitializeBackend(true);
 267   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 268       syncer::ControlTypes()));
 269   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
 270       syncer::ControlTypes()));
 271   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 272       syncer::ControlTypes()).Empty());
 273 }
 274
 275 // Test first time sync scenario. All types should be properly configured.
 276 TEST_F(SyncBackendHostTest, FirstTimeSync) {
 277   InitializeBackend(true);
 278   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 279       syncer::ControlTypes()));
 280   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
 281       syncer::ControlTypes()));
 282   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 283       syncer::ControlTypes()).Empty());
 284
 285   ConfigureDataTypes(enabled_types_,
 286                      Difference(syncer::ModelTypeSet::All(),
 287                                 enabled_types_));
 288   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
 289       Difference(enabled_types_, syncer::ControlTypes())));
 290   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 291   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 292   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 293       enabled_types_).Empty());
 294 }
 295
 296 // Test the restart after setting up sync scenario. No enabled types should be
 297 // downloaded or cleaned.
 298 TEST_F(SyncBackendHostTest, Restart) {
 299   sync_prefs_->SetSyncSetupCompleted();
 300   syncer::ModelTypeSet all_but_nigori = enabled_types_;
 301   fake_manager_factory_->set_progress_marker_types(enabled_types_);
 302   fake_manager_factory_->set_initial_sync_ended_types(enabled_types_);
 303   InitializeBackend(true);
 304   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
 305   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 306                            enabled_types_).Empty());
 307   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 308   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 309       enabled_types_).Empty());
 310
 311   ConfigureDataTypes(enabled_types_,
 312                      Difference(syncer::ModelTypeSet::All(),
 313                                 enabled_types_));
 314   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
 315   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 316                            enabled_types_).Empty());
 317   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 318   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 319   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 320       enabled_types_).Empty());
 321 }
 322
 323 // Test a sync restart scenario where some types had never finished configuring.
 324 // The partial types should be purged, then reconfigured properly.
 325 TEST_F(SyncBackendHostTest, PartialTypes) {
 326   sync_prefs_->SetSyncSetupCompleted();
 327   // Set sync manager behavior before passing it down. All types have progress
 328   // markers, but nigori and bookmarks are missing initial sync ended.
 329   syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS);
 330   syncer::ModelTypeSet full_types =
 331       Difference(enabled_types_, partial_types);
 332   fake_manager_factory_->set_progress_marker_types(enabled_types_);
 333   fake_manager_factory_->set_initial_sync_ended_types(full_types);
 334
 335   // Bringing up the backend should purge all partial types, then proceed to
 336   // download the Nigori.
 337   InitializeBackend(true);
 338   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 339       syncer::ModelTypeSet(syncer::NIGORI)));
 340   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
 341   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
 342       Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
 343   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 344       enabled_types_).Equals(
 345           Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI))));
 346
 347   // Now do the actual configuration, which should download and apply bookmarks.
 348   ConfigureDataTypes(enabled_types_,
 349                      Difference(syncer::ModelTypeSet::All(),
 350                                 enabled_types_));
 351   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 352                            enabled_types_).Empty());
 353   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 354       partial_types));
 355   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 356   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 357   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 358       enabled_types_).Empty());
 359 }
 360
 361 // Test the behavior when we lose the sync db. Although we already have types
 362 // enabled, we should re-download all of them because we lost their data.
 363 TEST_F(SyncBackendHostTest, LostDB) {
 364   sync_prefs_->SetSyncSetupCompleted();
 365   // Initialization should fetch the Nigori node.  Everything else should be
 366   // left untouched.
 367   InitializeBackend(true);
 368   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 369       syncer::ModelTypeSet(syncer::ControlTypes())));
 370   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
 371       syncer::ModelTypeSet(syncer::ControlTypes())));
 372   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 373       enabled_types_).Equals(
 374           Difference(enabled_types_, syncer::ControlTypes())));
 375
 376   // The database was empty, so any cleaning is entirely optional.  We want to
 377   // reset this value before running the next part of the test, though.
 378   fake_manager_->GetAndResetCleanedTypes();
 379
 380   // The actual configuration should redownload and apply all the enabled types.
 381   ConfigureDataTypes(enabled_types_,
 382                      Difference(syncer::ModelTypeSet::All(),
 383                                 enabled_types_));
 384   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
 385       Difference(enabled_types_, syncer::ControlTypes())));
 386   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 387                            enabled_types_).Empty());
 388   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 389   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 390   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 391       enabled_types_).Empty());
 392 }
 393
 394 TEST_F(SyncBackendHostTest, DisableTypes) {
 395   // Simulate first time sync.
 396   InitializeBackend(true);
 397   fake_manager_->GetAndResetCleanedTypes();
 398   ConfigureDataTypes(enabled_types_,
 399                      Difference(syncer::ModelTypeSet::All(),
 400                                 enabled_types_));
 401   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 402       enabled_types_));
 403   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 404                            enabled_types_).Empty());
 405   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 406   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 407       enabled_types_).Empty());
 408
 409   // Then disable two datatypes.
 410   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
 411                                       syncer::SEARCH_ENGINES);
 412   syncer::ModelTypeSet old_types = enabled_types_;
 413   enabled_types_.RemoveAll(disabled_types);
 414   ConfigureDataTypes(enabled_types_,
 415                      Difference(syncer::ModelTypeSet::All(),
 416                                 enabled_types_));
 417
 418   // Only those datatypes disabled should be cleaned. Nothing should be
 419   // downloaded.
 420   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
 421   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 422                            old_types).Equals(disabled_types));
 423   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 424   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 425   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 426       enabled_types_).Empty());
 427 }
 428
 429 TEST_F(SyncBackendHostTest, AddTypes) {
 430   // Simulate first time sync.
 431   InitializeBackend(true);
 432   fake_manager_->GetAndResetCleanedTypes();
 433   ConfigureDataTypes(enabled_types_,
 434                      Difference(syncer::ModelTypeSet::All(),
 435                                 enabled_types_));
 436   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 437       enabled_types_));
 438   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 439                            enabled_types_).Empty());
 440   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 441   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 442       enabled_types_).Empty());
 443
 444   // Then add two datatypes.
 445   syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
 446                                  syncer::APPS);
 447   enabled_types_.PutAll(new_types);
 448   ConfigureDataTypes(enabled_types_,
 449                      Difference(syncer::ModelTypeSet::All(),
 450                                 enabled_types_));
 451
 452   // Only those datatypes added should be downloaded (plus nigori). Nothing
 453   // should be cleaned aside from the disabled types.
 454   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 455       Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
 456   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 457                            enabled_types_).Empty());
 458   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 459   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 460   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 461       enabled_types_).Empty());
 462 }
 463
 464 // And and disable in the same configuration.
 465 TEST_F(SyncBackendHostTest, AddDisableTypes) {
 466   // Simulate first time sync.
 467   InitializeBackend(true);
 468   fake_manager_->GetAndResetCleanedTypes();
 469   ConfigureDataTypes(enabled_types_,
 470                      Difference(syncer::ModelTypeSet::All(),
 471                                 enabled_types_));
 472   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 473       enabled_types_));
 474   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 475                            enabled_types_).Empty());
 476   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 477   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 478       enabled_types_).Empty());
 479
 480   // Then add two datatypes.
 481   syncer::ModelTypeSet old_types = enabled_types_;
 482   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
 483                                       syncer::SEARCH_ENGINES);
 484   syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
 485                                  syncer::APPS);
 486   enabled_types_.PutAll(new_types);
 487   enabled_types_.RemoveAll(disabled_types);
 488   ConfigureDataTypes(enabled_types_,
 489                      Difference(syncer::ModelTypeSet::All(),
 490                                 enabled_types_));
 491
 492   // Only those datatypes added should be downloaded (plus nigori). Nothing
 493   // should be cleaned aside from the disabled types.
 494   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 495       Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
 496   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 497                            old_types).Equals(disabled_types));
 498   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 499   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 500   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 501       old_types).Equals(disabled_types));
 502 }
 503
 504 // Test restarting the browser to newly supported datatypes. The new datatypes
 505 // should be downloaded on the configuration after backend initialization.
 506 TEST_F(SyncBackendHostTest, NewlySupportedTypes) {
 507   sync_prefs_->SetSyncSetupCompleted();
 508   // Set sync manager behavior before passing it down. All types have progress
 509   // markers and initial sync ended except the new types.
 510   syncer::ModelTypeSet old_types = enabled_types_;
 511   fake_manager_factory_->set_progress_marker_types(old_types);
 512   fake_manager_factory_->set_initial_sync_ended_types(old_types);
 513   syncer::ModelTypeSet new_types(syncer::APP_SETTINGS,
 514                                  syncer::EXTENSION_SETTINGS);
 515   enabled_types_.PutAll(new_types);
 516
 517   // Does nothing.
 518   InitializeBackend(true);
 519   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
 520   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 521                            old_types).Empty());
 522   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(old_types));
 523   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 524       enabled_types_).Equals(new_types));
 525
 526   // Downloads and applies the new types.
 527   ConfigureDataTypes(enabled_types_,
 528                      Difference(syncer::ModelTypeSet::All(),
 529                                 enabled_types_));
 530   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 531       Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
 532   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 533                            enabled_types_).Empty());
 534   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 535   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 536   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 537       enabled_types_).Empty());
 538 }
 539
 540 // Test the newly supported types scenario, but with the presence of partial
 541 // types as well. Both partial and newly supported types should be downloaded
 542 // the configuration.
 543 TEST_F(SyncBackendHostTest, NewlySupportedTypesWithPartialTypes) {
 544   sync_prefs_->SetSyncSetupCompleted();
 545   // Set sync manager behavior before passing it down. All types have progress
 546   // markers and initial sync ended except the new types.
 547   syncer::ModelTypeSet old_types = enabled_types_;
 548   syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS);
 549   syncer::ModelTypeSet full_types =
 550       Difference(enabled_types_, partial_types);
 551   fake_manager_factory_->set_progress_marker_types(old_types);
 552   fake_manager_factory_->set_initial_sync_ended_types(full_types);
 553   syncer::ModelTypeSet new_types(syncer::APP_SETTINGS,
 554                                  syncer::EXTENSION_SETTINGS);
 555   enabled_types_.PutAll(new_types);
 556
 557   // Purge the partial types.  The nigori will be among the purged types, but
 558   // the syncer will re-download it by the time the initialization is complete.
 559   InitializeBackend(true);
 560   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 561       syncer::ModelTypeSet(syncer::NIGORI)));
 562   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
 563   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
 564       syncer::Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
 565   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 566       enabled_types_).Equals(Union(new_types, Difference(
 567                       partial_types, syncer::ModelTypeSet(syncer::NIGORI)))));
 568
 569   // Downloads and applies the new types and partial types (which includes
 570   // nigori anyways).
 571   ConfigureDataTypes(enabled_types_,
 572                      Difference(syncer::ModelTypeSet::All(),
 573                                 enabled_types_));
 574   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
 575       Union(new_types, partial_types)));
 576   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
 577                            enabled_types_).Empty());
 578   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 579   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
 580   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 581       enabled_types_).Empty());
 582 }
 583
 584 // Ensure the device info tracker is initialized properly on startup.
 585 TEST_F(SyncBackendHostTest, InitializeDeviceInfo) {
 586   ASSERT_EQ(NULL, backend_->GetSyncedDeviceTracker());
 587
 588   InitializeBackend(true);
 589   const SyncedDeviceTracker* device_tracker =
 590       backend_->GetSyncedDeviceTracker();
 591   ASSERT_TRUE(device_tracker->ReadLocalDeviceInfo());
 592 }
 593
 594 // Verify that downloading control types only downloads those types that do
 595 // not have initial sync ended set.
 596 TEST_F(SyncBackendHostTest, DownloadControlTypes) {
 597   sync_prefs_->SetSyncSetupCompleted();
 598   // Set sync manager behavior before passing it down. Experiments and device
 599   // info are new types without progress markers or initial sync ended, while
 600   // all other types have been fully downloaded and applied.
 601   syncer::ModelTypeSet new_types(syncer::EXPERIMENTS, syncer::DEVICE_INFO);
 602   syncer::ModelTypeSet old_types =
 603       Difference(enabled_types_, new_types);
 604   fake_manager_factory_->set_progress_marker_types(old_types);
 605   fake_manager_factory_->set_initial_sync_ended_types(old_types);
 606
 607   // Bringing up the backend should download the new types without downloading
 608   // any old types.
 609   InitializeBackend(true);
 610   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types));
 611   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().Equals(
 612                   Difference(syncer::ModelTypeSet::All(),
 613                              enabled_types_)));
 614   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
 615   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
 616       enabled_types_).Empty());
 617 }
 618
 619 // Fail to download control types.  It's believed that there is a server bug
 620 // which can allow this to happen (crbug.com/164288).  The sync backend host
 621 // should detect this condition and fail to initialize the backend.
 622 //
 623 // The failure is "silent" in the sense that the GetUpdates request appears to
 624 // be successful, but it returned no results.  This means that the usual
 625 // download retry logic will not be invoked.
 626 TEST_F(SyncBackendHostTest, SilentlyFailToDownloadControlTypes) {
 627   fake_manager_factory_->set_configure_fail_types(syncer::ModelTypeSet::All());
 628   InitializeBackend(false);
 629 }
 630
 631 // Test that local refresh requests are delivered to sync.
 632 TEST_F(SyncBackendHostTest, ForwardLocalRefreshRequest) {
 633   InitializeBackend(true);
 634
 635   syncer::ModelTypeSet set1 = syncer::ModelTypeSet::All();
 636   IssueRefreshRequest(set1);
 637   fake_manager_->WaitForSyncThread();
 638   EXPECT_TRUE(set1.Equals(fake_manager_->GetLastRefreshRequestTypes()));
 639
 640   syncer::ModelTypeSet set2 = syncer::ModelTypeSet(syncer::SESSIONS);
 641   IssueRefreshRequest(set2);
 642   fake_manager_->WaitForSyncThread();
 643   EXPECT_TRUE(set2.Equals(fake_manager_->GetLastRefreshRequestTypes()));
 644 }
 645
 646 // Test that local invalidations issued before sync is initialized are ignored.
 647 TEST_F(SyncBackendHostTest, AttemptForwardLocalRefreshRequestEarly) {
 648   syncer::ModelTypeSet set1 = syncer::ModelTypeSet::All();
 649   IssueRefreshRequest(set1);
 650
 651   InitializeBackend(true);
 652
 653   fake_manager_->WaitForSyncThread();
 654   EXPECT_FALSE(set1.Equals(fake_manager_->GetLastRefreshRequestTypes()));
 655 }
 656
 657 // Test that local invalidations issued while sync is shutting down are ignored.
 658 TEST_F(SyncBackendHostTest, AttemptForwardLocalRefreshRequestLate) {
 659   InitializeBackend(true);
 660
 661   backend_->StopSyncingForShutdown();
 662
 663   syncer::ModelTypeSet types = syncer::ModelTypeSet::All();
 664   IssueRefreshRequest(types);
 665   fake_manager_->WaitForSyncThread();
 666   EXPECT_FALSE(types.Equals(fake_manager_->GetLastRefreshRequestTypes()));
 667
 668   backend_->Shutdown(SyncBackendHost::STOP);
 669   backend_.reset();
 670 }
 671
 672 // Test that configuration on signin sends the proper GU source.
 673 TEST_F(SyncBackendHostTest, DownloadControlTypesNewClient) {
 674   InitializeBackend(true);
 675   EXPECT_EQ(syncer::CONFIGURE_REASON_NEW_CLIENT,
 676             fake_manager_->GetAndResetConfigureReason());
 677 }
 678
 679 // Test that configuration on restart sends the proper GU source.
 680 TEST_F(SyncBackendHostTest, DownloadControlTypesRestart) {
 681   sync_prefs_->SetSyncSetupCompleted();
 682   fake_manager_factory_->set_progress_marker_types(enabled_types_);
 683   fake_manager_factory_->set_initial_sync_ended_types(enabled_types_);
 684   InitializeBackend(true);
 685   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE,
 686             fake_manager_->GetAndResetConfigureReason());
 687 }
 688
 689 }  // namespace
 690
 691 }  // namespace browser_sync