Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

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 "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/driver/data_type_controller.h"
 
-namespace syncer {
+namespace sync_driver {
 
 FakeSyncService::FakeSyncService()
     : error_(GoogleServiceAuthError::NONE),
-      user_share_(base::MakeUnique<UserShare>()) {}
+      user_share_(base::MakeUnique<syncer::UserShare>()) {}
 
 FakeSyncService::~FakeSyncService() {}
 
 bool FakeSyncService::IsFirstSetupComplete() const {
   return false;
 }
 
 bool FakeSyncService::IsSyncAllowed() const {
   return false;
 }
 
 bool FakeSyncService::IsSyncActive() const {
   return false;
 }
 
-void FakeSyncService::TriggerRefresh(const ModelTypeSet& types) {}
+void FakeSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) {}
 
-ModelTypeSet FakeSyncService::GetActiveDataTypes() const {
-  return ModelTypeSet();
+syncer::ModelTypeSet FakeSyncService::GetActiveDataTypes() const {
+  return syncer::ModelTypeSet();
 }
 
 SyncClient* FakeSyncService::GetSyncClient() const {
   return nullptr;
 }
 
 void FakeSyncService::AddObserver(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(ModelType type) {}
+void FakeSyncService::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {}
 
-void FakeSyncService::RequestStop(SyncService::SyncStopDataFate data_fate) {}
+void FakeSyncService::RequestStop(
+    sync_driver::SyncService::SyncStopDataFate data_fate) {}
 
 void FakeSyncService::RequestStart() {}
 
-ModelTypeSet FakeSyncService::GetPreferredDataTypes() const {
-  return ModelTypeSet();
+syncer::ModelTypeSet FakeSyncService::GetPreferredDataTypes() const {
+  return syncer::ModelTypeSet();
 }
 
 void FakeSyncService::OnUserChoseDatatypes(bool sync_everything,
-                                           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 41 matching lines @@
   return false;
 }
 
 void FakeSyncService::SetEncryptionPassphrase(const std::string& passphrase,
                                               PassphraseType type) {}
 
 bool FakeSyncService::SetDecryptionPassphrase(const std::string& passphrase) {
   return false;
 }
 
-bool FakeSyncService::IsCryptographerReady(const BaseTransaction* trans) const {
+bool FakeSyncService::IsCryptographerReady(
+    const syncer::BaseTransaction* trans) const {
   return false;
 }
 
-UserShare* FakeSyncService::GetUserShare() const {
+syncer::UserShare* FakeSyncService::GetUserShare() const {
   return user_share_.get();
 }
 
 LocalDeviceInfoProvider* FakeSyncService::GetLocalDeviceInfoProvider() const {
   return nullptr;
 }
 
 void FakeSyncService::RegisterDataTypeController(
-    std::unique_ptr<DataTypeController> data_type_controller) {}
+    std::unique_ptr<sync_driver::DataTypeController> data_type_controller) {}
 
-void FakeSyncService::ReenableDatatype(ModelType type) {}
+void FakeSyncService::ReenableDatatype(syncer::ModelType type) {}
 
 bool FakeSyncService::IsPassphraseRequired() const {
   return false;
 }
 
-ModelTypeSet FakeSyncService::GetEncryptedDataTypes() const {
-  return ModelTypeSet();
+syncer::ModelTypeSet FakeSyncService::GetEncryptedDataTypes() const {
+  return syncer::ModelTypeSet();
 }
 
 FakeSyncService::SyncTokenStatus FakeSyncService::GetSyncTokenStatus() const {
   return FakeSyncService::SyncTokenStatus();
 }
 
 std::string FakeSyncService::QuerySyncStatusSummaryString() {
   return "";
 }
 
-bool FakeSyncService::QueryDetailedSyncStatus(SyncStatus* result) {
+bool FakeSyncService::QueryDetailedSyncStatus(syncer::SyncStatus* result) {
   return false;
 }
 
 base::string16 FakeSyncService::GetLastSyncedTimeString() const {
   return base::string16();
 }
 
 std::string FakeSyncService::GetBackendInitializationStateString() const {
   return std::string();
 }
 
-SyncCycleSnapshot FakeSyncService::GetLastCycleSnapshot() const {
-  return SyncCycleSnapshot();
+syncer::SyncCycleSnapshot FakeSyncService::GetLastCycleSnapshot() const {
+  return syncer::SyncCycleSnapshot();
 }
 
 base::Value* FakeSyncService::GetTypeStatusMap() const {
   return new base::ListValue();
 }
 
 const GURL& FakeSyncService::sync_service_url() const {
   return sync_service_url_;
 }
 
 std::string FakeSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location FakeSyncService::unrecoverable_error_location()
     const {
   return tracked_objects::Location();
 }
 
 void FakeSyncService::AddProtocolEventObserver(
-    ProtocolEventObserver* observer) {}
+    browser_sync::ProtocolEventObserver* observer) {}
 
 void FakeSyncService::RemoveProtocolEventObserver(
-    ProtocolEventObserver* observer) {}
+    browser_sync::ProtocolEventObserver* observer) {}
 
 void FakeSyncService::AddTypeDebugInfoObserver(
-    TypeDebugInfoObserver* observer) {}
+    syncer::TypeDebugInfoObserver* observer) {}
 
 void FakeSyncService::RemoveTypeDebugInfoObserver(
-    TypeDebugInfoObserver* observer) {}
+    syncer::TypeDebugInfoObserver* observer) {}
 
-base::WeakPtr<JsController> FakeSyncService::GetJsController() {
-  return base::WeakPtr<JsController>();
+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 syncer
+}  // namespace sync_driver