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

components/sync/driver/glue/sync_backend_registrar_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/sync_driver/glue/sync_backend_registrar.h"
+#include "components/sync/driver/glue/sync_backend_registrar.h"
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/core/test/test_user_share.h"
+#include "components/sync/driver/change_processor_mock.h"
+#include "components/sync/driver/fake_sync_client.h"
+#include "components/sync/driver/glue/browser_thread_model_worker.h"
+#include "components/sync/driver/sync_api_component_factory_mock.h"
 #include "components/sync/engine/passive_model_worker.h"
-#include "components/sync_driver/change_processor_mock.h"
-#include "components/sync_driver/fake_sync_client.h"
-#include "components/sync_driver/glue/browser_thread_model_worker.h"
-#include "components/sync_driver/sync_api_component_factory_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
 namespace {
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
@@ skipping 47 matching lines @@
   const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> db_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 };
 
 // Flaky: https://crbug.com/498238
 class SyncBackendRegistrarTest : public testing::Test {
  public:
   void TestNonUIDataTypeActivationAsync(sync_driver::ChangeProcessor* processor,
                                         base::WaitableEvent* done) {
-    registrar_->ActivateDataType(AUTOFILL,
-                                 syncer::GROUP_DB,
-                                 processor,
+    registrar_->ActivateDataType(AUTOFILL, syncer::GROUP_DB, processor,
                                  test_user_share_.user_share());
     syncer::ModelSafeRoutingInfo expected_routing_info;
     expected_routing_info[AUTOFILL] = syncer::GROUP_DB;
     ExpectRoutingInfo(registrar_.get(), expected_routing_info);
     ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet(AUTOFILL));
     TriggerChanges(registrar_.get(), AUTOFILL);
     done->Signal();
   }
 
  protected:
@@ skipping 63 matching lines @@
   std::unique_ptr<RegistrarSyncClient> sync_client_;
   std::unique_ptr<SyncBackendRegistrar> registrar_;
 
   base::Thread* sync_thread_;
 };
 
 TEST_F(SyncBackendRegistrarTest, ConstructorEmpty) {
   registrar_->SetInitialTypes(ModelTypeSet());
   EXPECT_FALSE(registrar_->IsNigoriEnabled());
   {
-    std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
+    std::vector<scoped_refptr<syncer::ModelSafeWorker>> workers;
     registrar_->GetWorkers(&workers);
     EXPECT_EQ(4u, workers.size());
   }
   ExpectRoutingInfo(registrar_.get(), syncer::ModelSafeRoutingInfo());
   ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet());
 }
 
 TEST_F(SyncBackendRegistrarTest, ConstructorNonEmpty) {
   const ModelTypeSet initial_types(BOOKMARKS, NIGORI, PASSWORDS);
   registrar_->RegisterNonBlockingType(BOOKMARKS);
   registrar_->SetInitialTypes(initial_types);
   EXPECT_TRUE(registrar_->IsNigoriEnabled());
   {
-    std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
+    std::vector<scoped_refptr<syncer::ModelSafeWorker>> workers;
     registrar_->GetWorkers(&workers);
     EXPECT_EQ(4u, workers.size());
   }
   {
     syncer::ModelSafeRoutingInfo expected_routing_info;
     expected_routing_info[BOOKMARKS] = syncer::GROUP_NON_BLOCKING;
     expected_routing_info[NIGORI] = syncer::GROUP_PASSIVE;
     // Passwords dropped because of no password store.
     ExpectRoutingInfo(registrar_.get(), expected_routing_info);
   }
@@ skipping 38 matching lines @@
 
 TEST_F(SyncBackendRegistrarTest, ActivateDeactivateUIDataType) {
   InSequence in_sequence;
   registrar_->SetInitialTypes(ModelTypeSet());
 
   // Should do nothing.
   TriggerChanges(registrar_.get(), BOOKMARKS);
 
   StrictMock<sync_driver::ChangeProcessorMock> change_processor_mock;
   EXPECT_CALL(change_processor_mock, StartImpl());
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(true));
   EXPECT_CALL(change_processor_mock, ApplyChangesFromSyncModel(NULL, _, _));
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(true));
   EXPECT_CALL(change_processor_mock, CommitChangesFromSyncModel());
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(false));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(false));
 
   const ModelTypeSet types(BOOKMARKS);
   EXPECT_EQ(types, registrar_->ConfigureDataTypes(types, ModelTypeSet()));
   registrar_->ActivateDataType(BOOKMARKS, syncer::GROUP_UI,
-                             &change_processor_mock,
-                             test_user_share_.user_share());
+                               &change_processor_mock,
+                               test_user_share_.user_share());
   {
     syncer::ModelSafeRoutingInfo expected_routing_info;
     expected_routing_info[BOOKMARKS] = syncer::GROUP_UI;
     ExpectRoutingInfo(registrar_.get(), expected_routing_info);
   }
   ExpectHasProcessorsForTypes(*registrar_, types);
 
   TriggerChanges(registrar_.get(), BOOKMARKS);
 
   registrar_->DeactivateDataType(BOOKMARKS);
   ExpectRoutingInfo(registrar_.get(), syncer::ModelSafeRoutingInfo());
   ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet());
 
   // Should do nothing.
   TriggerChanges(registrar_.get(), BOOKMARKS);
 }
 
 TEST_F(SyncBackendRegistrarTest, ActivateDeactivateNonUIDataType) {
   InSequence in_sequence;
   registrar_->SetInitialTypes(ModelTypeSet());
 
   // Should do nothing.
   TriggerChanges(registrar_.get(), AUTOFILL);
 
   StrictMock<sync_driver::ChangeProcessorMock> change_processor_mock;
   EXPECT_CALL(change_processor_mock, StartImpl());
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(true));
   EXPECT_CALL(change_processor_mock, ApplyChangesFromSyncModel(NULL, _, _));
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(true));
   EXPECT_CALL(change_processor_mock, CommitChangesFromSyncModel());
-  EXPECT_CALL(change_processor_mock, IsRunning())
-      .WillRepeatedly(Return(false));
+  EXPECT_CALL(change_processor_mock, IsRunning()).WillRepeatedly(Return(false));
 
   const ModelTypeSet types(AUTOFILL);
   EXPECT_EQ(types, registrar_->ConfigureDataTypes(types, ModelTypeSet()));
 
   base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   db_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendRegistrarTest::TestNonUIDataTypeActivationAsync,
                  base::Unretained(this), &change_processor_mock, &done));
@@ skipping 159 matching lines @@
   db_thread_lock_.Release();
 
   // Run the main thread loop until all workers have been removed and the
   // registrar destroyed.
   run_loop_.Run();
 }
 
 }  // namespace
 
 }  // namespace browser_sync