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

components/sync/driver/fake_sync_service.cc

 // Copyright 2015 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/fake_sync_service.h"
+#include "components/sync/driver/fake_sync_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/sync/core/base_transaction.h"
 #include "components/sync/core/user_share.h"
 #include "components/sync/sessions/sync_session_snapshot.h"
 
 namespace sync_driver {
 
 FakeSyncService::FakeSyncService()
     : error_(GoogleServiceAuthError::NONE),
       user_share_(base::WrapUnique(new syncer::UserShare())) {}
 
-FakeSyncService::~FakeSyncService() {
-}
+FakeSyncService::~FakeSyncService() {}
 
 bool FakeSyncService::IsFirstSetupComplete() const {
   return false;
 }
 
 bool FakeSyncService::IsSyncAllowed() const {
   return false;
 }
 
 bool FakeSyncService::IsSyncActive() const {
   return false;
 }
 
 void FakeSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) {}
 
 syncer::ModelTypeSet FakeSyncService::GetActiveDataTypes() const {
   return syncer::ModelTypeSet();
 }
 
 SyncClient* FakeSyncService::GetSyncClient() const {
   return nullptr;
 }
 
-void FakeSyncService::AddObserver(SyncServiceObserver* observer) {
-}
+void FakeSyncService::AddObserver(SyncServiceObserver* observer) {}
 
-void FakeSyncService::RemoveObserver(SyncServiceObserver* observer) {
-}
+void FakeSyncService::RemoveObserver(SyncServiceObserver* observer) {}
 
 bool FakeSyncService::HasObserver(const SyncServiceObserver* observer) const {
   return false;
 }
 
 bool FakeSyncService::CanSyncStart() const {
   return false;
 }
 
-void FakeSyncService::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {
-}
+void FakeSyncService::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {}
 
 void FakeSyncService::RequestStop(
-    sync_driver::SyncService::SyncStopDataFate data_fate) {
-}
+    sync_driver::SyncService::SyncStopDataFate data_fate) {}
 
-void FakeSyncService::RequestStart() {
-}
+void FakeSyncService::RequestStart() {}
 
 syncer::ModelTypeSet FakeSyncService::GetPreferredDataTypes() const {
   return syncer::ModelTypeSet();
 }
 
 void FakeSyncService::OnUserChoseDatatypes(bool sync_everything,
-                                           syncer::ModelTypeSet chosen_types) {
-}
+                                           syncer::ModelTypeSet chosen_types) {}
 
 void FakeSyncService::SetFirstSetupComplete() {}
 
 bool FakeSyncService::IsFirstSetupInProgress() const {
   return false;
 }
 
 std::unique_ptr<SyncSetupInProgressHandle>
 FakeSyncService::GetSetupInProgressHandle() {
   return nullptr;
@@ skipping 28 matching lines @@
 }
 
 base::Time FakeSyncService::GetExplicitPassphraseTime() const {
   return base::Time();
 }
 
 bool FakeSyncService::IsUsingSecondaryPassphrase() const {
   return false;
 }
 
-void FakeSyncService::EnableEncryptEverything() {
-}
+void FakeSyncService::EnableEncryptEverything() {}
 
 bool FakeSyncService::IsEncryptEverythingEnabled() const {
   return false;
 }
 
 void FakeSyncService::SetEncryptionPassphrase(const std::string& passphrase,
-                                              PassphraseType type) {
-}
+                                              PassphraseType type) {}
 
 bool FakeSyncService::SetDecryptionPassphrase(const std::string& passphrase) {
   return false;
 }
 
 bool FakeSyncService::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return false;
 }
 
 syncer::UserShare* FakeSyncService::GetUserShare() const {
   return user_share_.get();
 }
 
 LocalDeviceInfoProvider* FakeSyncService::GetLocalDeviceInfoProvider() const {
   return nullptr;
 }
 
 void FakeSyncService::RegisterDataTypeController(
-      sync_driver::DataTypeController* data_type_controller) {
-}
+    sync_driver::DataTypeController* data_type_controller) {}
 
 void FakeSyncService::ReenableDatatype(syncer::ModelType type) {}
 
 bool FakeSyncService::IsPassphraseRequired() const {
   return false;
 }
 
 syncer::ModelTypeSet FakeSyncService::GetEncryptedDataTypes() const {
   return syncer::ModelTypeSet();
 }
@@ skipping 53 matching lines @@
     syncer::TypeDebugInfoObserver* observer) {}
 
 base::WeakPtr<syncer::JsController> FakeSyncService::GetJsController() {
   return base::WeakPtr<syncer::JsController>();
 }
 
 void FakeSyncService::GetAllNodes(
     const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) {}
 
 }  // namespace sync_driver