chrome/browser/sync/glue/sync_backend_host_impl_unittest.cc

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