[Sync] Move //components/sync_driver to //components/sync/driver.

components/sync/driver/glue/sync_backend_host_impl_unittest.cc

 // Copyright 2013 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/glue/sync_backend_host_impl.h"
+#include "components/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/invalidation/impl/invalidator_storage.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidator_state.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/sync/base/experiments.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/test_unrecoverable_error_handler.h"
 #include "components/sync/core/http_bridge_network_resources.h"
 #include "components/sync/core/network_resources.h"
 #include "components/sync/core/sync_manager_factory.h"
 #include "components/sync/core/test/fake_sync_manager.h"
+#include "components/sync/driver/device_info.h"
+#include "components/sync/driver/fake_sync_client.h"
+#include "components/sync/driver/sync_frontend.h"
+#include "components/sync/driver/sync_prefs.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine/passive_model_worker.h"
 #include "components/sync/protocol/encryption.pb.h"
 #include "components/sync/protocol/sync_protocol_error.h"
 #include "components/sync/sessions/commit_counters.h"
 #include "components/sync/sessions/status_counters.h"
 #include "components/sync/sessions/update_counters.h"
 #include "components/sync/test/callback_counter.h"
-#include "components/sync_driver/device_info.h"
-#include "components/sync_driver/fake_sync_client.h"
-#include "components/sync_driver/sync_frontend.h"
-#include "components/sync_driver/sync_prefs.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 26 matching lines @@
  public:
   virtual ~MockSyncFrontend() {}
 
   MOCK_METHOD4(
       OnBackendInitialized,
       void(const syncer::WeakHandle<syncer::JsBackend>&,
            const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&,
            const std::string&,
            bool));
   MOCK_METHOD0(OnSyncCycleCompleted, void());
-  MOCK_METHOD1(OnConnectionStatusChange,
-               void(syncer::ConnectionStatus status));
+  MOCK_METHOD1(OnConnectionStatusChange, void(syncer::ConnectionStatus status));
   MOCK_METHOD0(OnClearServerDataSucceeded, void());
   MOCK_METHOD0(OnClearServerDataFailed, void());
   MOCK_METHOD2(OnPassphraseRequired,
                void(syncer::PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));
   MOCK_METHOD0(OnPassphraseAccepted, void());
-  MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(syncer::ModelTypeSet, bool));
+  MOCK_METHOD2(OnEncryptedTypesChanged, void(syncer::ModelTypeSet, bool));
   MOCK_METHOD0(OnEncryptionComplete, void());
   MOCK_METHOD1(OnMigrationNeededForTypes, void(syncer::ModelTypeSet));
   MOCK_METHOD1(OnProtocolEvent, void(const syncer::ProtocolEvent&));
   MOCK_METHOD2(OnDirectoryTypeCommitCounterUpdated,
                void(syncer::ModelType, const syncer::CommitCounters&));
   MOCK_METHOD2(OnDirectoryTypeUpdateCounterUpdated,
                void(syncer::ModelType, const syncer::UpdateCounters&));
   MOCK_METHOD2(OnDirectoryTypeStatusCounterUpdated,
                void(syncer::ModelType, const syncer::StatusCounters&));
-  MOCK_METHOD1(OnExperimentsChanged,
-      void(const syncer::Experiments&));
+  MOCK_METHOD1(OnExperimentsChanged, void(const syncer::Experiments&));
   MOCK_METHOD1(OnActionableError,
-      void(const syncer::SyncProtocolError& sync_error));
+               void(const syncer::SyncProtocolError& sync_error));
   MOCK_METHOD0(OnSyncConfigureRetry, void());
   MOCK_METHOD1(
       OnLocalSetPassphraseEncryption,
       void(const syncer::SyncEncryptionHandler::NigoriState& nigori_state));
 };
 
 class FakeSyncManagerFactory : public syncer::SyncManagerFactory {
  public:
   explicit FakeSyncManagerFactory(FakeSyncManager** fake_manager)
-     : fake_manager_(fake_manager) {
+      : fake_manager_(fake_manager) {
     *fake_manager_ = NULL;
   }
   ~FakeSyncManagerFactory() override {}
 
   // SyncManagerFactory implementation.  Called on the sync thread.
   std::unique_ptr<SyncManager> CreateSyncManager(
       const std::string& /* name */) override {
-    *fake_manager_ = new FakeSyncManager(initial_sync_ended_types_,
-                                         progress_marker_types_,
-                                         configure_fail_types_);
+    *fake_manager_ =
+        new FakeSyncManager(initial_sync_ended_types_, progress_marker_types_,
+                            configure_fail_types_);
     return std::unique_ptr<SyncManager>(*fake_manager_);
   }
 
   void set_initial_sync_ended_types(syncer::ModelTypeSet types) {
     initial_sync_ended_types_ = types;
   }
 
   void set_progress_marker_types(syncer::ModelTypeSet types) {
     progress_marker_types_ = types;
   }
@@ skipping 18 matching lines @@
       case syncer::GROUP_PASSIVE:
         return new syncer::PassiveModelWorker(observer);
       default:
         return nullptr;
     }
   }
 };
 
 class SyncBackendHostTest : public testing::Test {
  protected:
-  SyncBackendHostTest()
-      : fake_manager_(NULL) {}
+  SyncBackendHostTest() : fake_manager_(NULL) {}
 
   ~SyncBackendHostTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     sync_driver::SyncPrefs::RegisterProfilePrefs(pref_service_.registry());
 
     sync_prefs_.reset(new sync_driver::SyncPrefs(&pref_service_));
     backend_.reset(new SyncBackendHostImpl(
-        "dummyDebugName", &sync_client_,
-        base::ThreadTaskRunnerHandle::Get(),
-        nullptr,
-        sync_prefs_->AsWeakPtr(),
+        "dummyDebugName", &sync_client_, base::ThreadTaskRunnerHandle::Get(),
+        nullptr, sync_prefs_->AsWeakPtr(),
         temp_dir_.path().Append(base::FilePath(kTestSyncDir))));
     credentials_.account_id = "user@example.com";
     credentials_.email = "user@example.com";
     credentials_.sync_token = "sync_token";
     credentials_.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
 
     fake_manager_factory_.reset(new FakeSyncManagerFactory(&fake_manager_));
 
     // These types are always implicitly enabled.
     enabled_types_.PutAll(syncer::ControlTypes());
@@ skipping 15 matching lines @@
       backend_->Shutdown(syncer::STOP_SYNC);
     }
     backend_.reset();
     sync_prefs_.reset();
     // Pump messages posted by the sync thread.
     base::RunLoop().RunUntilIdle();
   }
 
   // Synchronously initializes the backend.
   void InitializeBackend(bool expect_success) {
-    EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, _, expect_success)).
-        WillOnce(InvokeWithoutArgs(QuitMessageLoop));
+    EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, _, expect_success))
+        .WillOnce(InvokeWithoutArgs(QuitMessageLoop));
     SyncBackendHost::HttpPostProviderFactoryGetter
         http_post_provider_factory_getter =
             base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
-                       base::Unretained(network_resources_.get()),
-                       nullptr,
+                       base::Unretained(network_resources_.get()), nullptr,
                        base::Bind(&EmptyNetworkTimeUpdate));
     backend_->Initialize(
         &mock_frontend_, std::unique_ptr<base::Thread>(),
         base::ThreadTaskRunnerHandle::Get(),
         base::ThreadTaskRunnerHandle::Get(),
         syncer::WeakHandle<syncer::JsEventHandler>(), GURL(std::string()),
         std::string(), credentials_, true, std::move(fake_manager_factory_),
         MakeWeakHandle(test_unrecoverable_error_handler_.GetWeakPtr()),
         base::Closure(), http_post_provider_factory_getter,
         std::move(saved_nigori_state_));
     base::RunLoop run_loop;
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
-        run_loop.QuitClosure(),
-        TestTimeouts::action_timeout());
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
     run_loop.Run();
     // |fake_manager_factory_|'s fake_manager() is set on the sync
     // thread, but we can rely on the message loop barriers to
     // guarantee that we see the updated value.
     DCHECK(fake_manager_);
   }
 
   // Synchronously configures the backend's datatypes.
   syncer::ModelTypeSet ConfigureDataTypes(
       syncer::ModelTypeSet types_to_add,
       syncer::ModelTypeSet types_to_remove,
       syncer::ModelTypeSet types_to_unapply) {
     sync_driver::BackendDataTypeConfigurer::DataTypeConfigStateMap
         config_state_map;
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
-        sync_driver::BackendDataTypeConfigurer::CONFIGURE_ACTIVE,
-        types_to_add,
+        sync_driver::BackendDataTypeConfigurer::CONFIGURE_ACTIVE, types_to_add,
         &config_state_map);
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
-        sync_driver::BackendDataTypeConfigurer::DISABLED,
-        types_to_remove, &config_state_map);
+        sync_driver::BackendDataTypeConfigurer::DISABLED, types_to_remove,
+        &config_state_map);
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
-        sync_driver::BackendDataTypeConfigurer::UNREADY,
-        types_to_unapply, &config_state_map);
+        sync_driver::BackendDataTypeConfigurer::UNREADY, types_to_unapply,
+        &config_state_map);
 
     types_to_add.PutAll(syncer::ControlTypes());
     syncer::ModelTypeSet ready_types = backend_->ConfigureDataTypes(
         syncer::CONFIGURE_REASON_RECONFIGURATION, config_state_map,
         base::Bind(&SyncBackendHostTest::DownloadReady, base::Unretained(this)),
         base::Bind(&SyncBackendHostTest::OnDownloadRetry,
                    base::Unretained(this)));
     base::RunLoop run_loop;
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
-        run_loop.QuitClosure(),
-        TestTimeouts::action_timeout());
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
     run_loop.Run();
     return ready_types;
   }
 
  protected:
   void DownloadReady(syncer::ModelTypeSet succeeded_types,
                      syncer::ModelTypeSet failed_types) {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
-  void OnDownloadRetry() {
-    NOTIMPLEMENTED();
-  }
+  void OnDownloadRetry() { NOTIMPLEMENTED(); }
 
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
   syncable_prefs::TestingPrefServiceSyncable pref_service_;
   StrictMock<MockSyncFrontend> mock_frontend_;
   syncer::SyncCredentials credentials_;
   BackendSyncClient sync_client_;
   syncer::TestUnrecoverableErrorHandler test_unrecoverable_error_handler_;
   std::unique_ptr<sync_driver::SyncPrefs> sync_prefs_;
   std::unique_ptr<SyncBackendHostImpl> backend_;
   std::unique_ptr<FakeSyncManagerFactory> fake_manager_factory_;
   FakeSyncManager* fake_manager_;
   syncer::ModelTypeSet enabled_types_;
   std::unique_ptr<syncer::NetworkResources> network_resources_;
   std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
       saved_nigori_state_;
 };
 
 // Test basic initialization with no initial types (first time initialization).
 // Only the nigori should be configured.
 TEST_F(SyncBackendHostTest, InitShutdown) {
   InitializeBackend(true);
   EXPECT_EQ(syncer::ControlTypes(),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(syncer::ControlTypes(), fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      syncer::ControlTypes()).Empty());
+  EXPECT_TRUE(fake_manager_
+                  ->GetTypesWithEmptyProgressMarkerToken(syncer::ControlTypes())
+                  .Empty());
 }
 
 // Test first time sync scenario. All types should be properly configured.
 TEST_F(SyncBackendHostTest, FirstTimeSync) {
   InitializeBackend(true);
   EXPECT_EQ(syncer::ControlTypes(),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(syncer::ControlTypes(), fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      syncer::ControlTypes()).Empty());
+  EXPECT_TRUE(fake_manager_
+                  ->GetTypesWithEmptyProgressMarkerToken(syncer::ControlTypes())
+                  .Empty());
 
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  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_->SetFirstSetupComplete();
   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(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   EXPECT_EQ(enabled_types_, ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 // Test a sync restart scenario where some types had never finished configuring.
 // The partial types should be purged, then reconfigured properly.
 TEST_F(SyncBackendHostTest, PartialTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // 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);
+  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(true);
   EXPECT_EQ(syncer::ModelTypeSet(syncer::NIGORI),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_EQ(Union(full_types, syncer::ModelTypeSet(syncer::NIGORI)),
             fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(
       Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI)),
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_));
 
   // Now do the actual configuration, which should download and apply bookmarks.
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   EXPECT_EQ(full_types, ready_types);
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(partial_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  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_->SetFirstSetupComplete();
   // Initialization should fetch the Nigori node.  Everything else should be
   // left untouched.
   InitializeBackend(true);
   EXPECT_EQ(syncer::ModelTypeSet(syncer::ControlTypes()),
@@ skipping 11 matching lines @@
   // The actual configuration should redownload and apply all the enabled types.
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 TEST_F(SyncBackendHostTest, DisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 
   // Then disable two datatypes.
   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
                                       syncer::SEARCH_ENGINES);
   syncer::ModelTypeSet old_types = enabled_types_;
   enabled_types_.RemoveAll(disabled_types);
   ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
 
   // Only those datatypes disabled should be cleaned. Nothing should be
   // downloaded.
   EXPECT_EQ(enabled_types_, ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_EQ(disabled_types,
             Intersection(fake_manager_->GetAndResetCleanedTypes(), old_types));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 TEST_F(SyncBackendHostTest, AddTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 
   // Then add two datatypes.
-  syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
-                                 syncer::APPS);
+  syncer::ModelTypeSet new_types(syncer::EXTENSIONS, syncer::APPS);
   enabled_types_.PutAll(new_types);
   ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
   new_types.Put(syncer::NIGORI);
   EXPECT_EQ(syncer::Difference(enabled_types_, new_types), ready_types);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 // And and disable in the same configuration.
 TEST_F(SyncBackendHostTest, AddDisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 
   // Then add two datatypes.
   syncer::ModelTypeSet old_types = enabled_types_;
   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
                                       syncer::SEARCH_ENGINES);
-  syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
-                                 syncer::APPS);
+  syncer::ModelTypeSet new_types(syncer::EXTENSIONS, syncer::APPS);
   enabled_types_.PutAll(new_types);
   enabled_types_.RemoveAll(disabled_types);
   ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
   new_types.Put(syncer::NIGORI);
   EXPECT_EQ(syncer::Difference(enabled_types_, new_types), ready_types);
@@ skipping 15 matching lines @@
   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(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           old_types).Empty());
+  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), old_types)
+                  .Empty());
   EXPECT_EQ(old_types, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(new_types, fake_manager_->GetTypesWithEmptyProgressMarkerToken(
                            enabled_types_));
 
   // Downloads and applies the new types (plus nigori).
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
 
   new_types.Put(syncer::NIGORI);
   EXPECT_EQ(syncer::Difference(old_types, syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 // Test the newly supported types scenario, but with the presence of partial
 // types as well. Both partial and newly supported types should be downloaded
 // the configuration.
 TEST_F(SyncBackendHostTest, NewlySupportedTypesWithPartialTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // 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_;
   syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS);
-  syncer::ModelTypeSet full_types =
-      Difference(enabled_types_, partial_types);
+  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(true);
   EXPECT_EQ(syncer::ModelTypeSet(syncer::NIGORI),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_EQ(syncer::Union(full_types, syncer::ModelTypeSet(syncer::NIGORI)),
             fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(
       Union(new_types,
             Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI))),
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_));
 
   // Downloads and applies the new types and partial types (which includes
   // nigori anyways).
   syncer::ModelTypeSet ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   EXPECT_EQ(full_types, ready_types);
   EXPECT_EQ(Union(new_types, partial_types),
             fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
-                           enabled_types_).Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+          .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
+          .Empty());
 }
 
 // Verify that downloading control types only downloads those types that do
 // not have initial sync ended set.
 TEST_F(SyncBackendHostTest, DownloadControlTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // 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::NIGORI);
-  syncer::ModelTypeSet old_types =
-      Difference(enabled_types_, new_types);
+  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(true);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(Difference(syncer::ModelTypeSet::All(), enabled_types_),
             fake_manager_->GetAndResetCleanedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      enabled_types_).Empty());
+  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) {
@@ skipping 30 matching lines @@
   fake_manager_factory_->set_initial_sync_ended_types(enabled_types_);
   InitializeBackend(true);
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE,
             fake_manager_->GetAndResetConfigureReason());
 }
 
 // It is SyncBackendHostCore responsibility to cleanup Sync Data folder if sync
 // setup hasn't been completed. This test ensures that cleanup happens.
 TEST_F(SyncBackendHostTest, TestStartupWithOldSyncData) {
   const char* nonsense = "slon";
-  base::FilePath temp_directory = temp_dir_.path().Append(
-      base::FilePath(kTestSyncDir));
+  base::FilePath temp_directory =
+      temp_dir_.path().Append(base::FilePath(kTestSyncDir));
   base::FilePath sync_file = temp_directory.AppendASCII("SyncData.sqlite3");
   ASSERT_TRUE(base::CreateDirectory(temp_directory));
   ASSERT_NE(-1, base::WriteFile(sync_file, nonsense, strlen(nonsense)));
 
   InitializeBackend(true);
 
   EXPECT_FALSE(base::PathExists(sync_file));
 }
 
 // If bookmarks encounter an error that results in disabling without purging
@@ skipping 13 matching lines @@
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(syncer::Difference(syncer::ControlTypes(),
                                syncer::ModelTypeSet(syncer::NIGORI)),
             ready_types);
 
   // Then mark the error types as unready (disables without purging).
   ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       error_types);
   EXPECT_EQ(syncer::Difference(enabled_types_, error_types), ready_types);
-  EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      error_types).Empty());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(error_types).Empty());
 
   // Lastly explicitly disable the error types, which should result in a purge.
   enabled_types_.RemoveAll(error_types);
   ready_types = ConfigureDataTypes(
       enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
       syncer::ModelTypeSet());
   EXPECT_EQ(syncer::Difference(enabled_types_, error_types), ready_types);
-  EXPECT_FALSE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
-      error_types).Empty());
+  EXPECT_FALSE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(error_types).Empty());
 }
 
 // Test that a call to ClearServerData is forwarded to the underlying
 // SyncManager.
 TEST_F(SyncBackendHostTest, ClearServerDataCallsAreForwarded) {
   InitializeBackend(true);
   syncer::CallbackCounter callback_counter;
   backend_->ClearServerData(base::Bind(&syncer::CallbackCounter::Callback,
                                        base::Unretained(&callback_counter)));
   fake_manager_->WaitForSyncThread();
@@ skipping 69 matching lines @@
   backend_->StopSyncingForShutdown();
   // Verify that call to DeactivateNonBlockingDataType doesn't assert.
   backend_->DeactivateNonBlockingDataType(syncer::AUTOFILL);
   backend_->Shutdown(syncer::STOP_SYNC);
   backend_.reset();
 }
 
 }  // namespace
 
 }  // namespace browser_sync