Revert of [Sync] Make directory types registration explicit in ModelTypeRegistry

components/sync/engine/fake_sync_manager.cc

 // Copyright (c) 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/engine/fake_sync_manager.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/weak_handle.h"
 #include "components/sync/engine/engine_components_factory.h"
+#include "components/sync/engine/fake_model_type_connector.h"
 #include "components/sync/engine/net/http_post_provider_factory.h"
 #include "components/sync/syncable/directory.h"
+#include "components/sync/test/fake_sync_encryption_handler.h"
 
 class GURL;
 
 namespace syncer {
 
 FakeSyncManager::FakeSyncManager(ModelTypeSet initial_sync_ended_types,
                                  ModelTypeSet progress_marker_types,
                                  ModelTypeSet configure_fail_types)
     : initial_sync_ended_types_(initial_sync_ended_types),
       progress_marker_types_(progress_marker_types),
       configure_fail_types_(configure_fail_types),
       last_configure_reason_(CONFIGURE_REASON_UNKNOWN),
-      num_invalidations_received_(0) {}
+      num_invalidations_received_(0) {
+  fake_encryption_handler_ = base::MakeUnique<FakeSyncEncryptionHandler>();
+}
 
 FakeSyncManager::~FakeSyncManager() {}
 
 ModelTypeSet FakeSyncManager::GetAndResetPurgedTypes() {
   ModelTypeSet purged_types = purged_types_;
   purged_types_.Clear();
   return purged_types;
 }
 
 ModelTypeSet FakeSyncManager::GetAndResetUnappliedTypes() {
   ModelTypeSet unapplied_types = unapplied_types_;
   unapplied_types_.Clear();
   return unapplied_types;
 }
 
 ModelTypeSet FakeSyncManager::GetAndResetDownloadedTypes() {
   ModelTypeSet downloaded_types = downloaded_types_;
   downloaded_types_.Clear();
   return downloaded_types;
 }
 
+ModelTypeSet FakeSyncManager::GetAndResetEnabledTypes() {
+  ModelTypeSet enabled_types = enabled_types_;
+  enabled_types_.Clear();
+  return enabled_types;
+}
+
 ConfigureReason FakeSyncManager::GetAndResetConfigureReason() {
   ConfigureReason reason = last_configure_reason_;
   last_configure_reason_ = CONFIGURE_REASON_UNKNOWN;
   return reason;
 }
 
 int FakeSyncManager::GetInvalidationCount() const {
   return num_invalidations_received_;
 }
 
@@ skipping 61 matching lines @@
   // Types from |to_unapply| should retain their server data and progress
   // markers.
   initial_sync_ended_types_.RemoveAll(Difference(to_purge, to_unapply));
   progress_marker_types_.RemoveAll(Difference(to_purge, to_unapply));
 }
 
 void FakeSyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   NOTIMPLEMENTED();
 }
 
-void FakeSyncManager::StartSyncingNormally(base::Time last_poll_time) {
-  // Do nothing.
-}
-
-void FakeSyncManager::StartConfiguration() {
+void FakeSyncManager::StartSyncingNormally(
+    const ModelSafeRoutingInfo& routing_info,
+    base::Time last_poll_time) {
   // Do nothing.
 }
 
 void FakeSyncManager::ConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
+    const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   last_configure_reason_ = reason;
+  enabled_types_ = GetRoutingInfoTypes(new_routing_info);
   ModelTypeSet success_types = to_download;
   success_types.RemoveAll(configure_fail_types_);
 
   DVLOG(1) << "Faking configuration. Downloading: "
            << ModelTypeSetToString(success_types);
 
   // Update our fake directory by clearing and fake-downloading as necessary.
   UserShare* share = GetUserShare();
   for (ModelTypeSet::Iterator it = success_types.First(); it.Good(); it.Inc()) {
     // We must be careful to not create the same root node twice.
@@ skipping 30 matching lines @@
 
 void FakeSyncManager::ShutdownOnSyncThread(ShutdownReason reason) {
   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
   test_user_share_.TearDown();
 }
 
 UserShare* FakeSyncManager::GetUserShare() {
   return test_user_share_.user_share();
 }
 
-ModelTypeConnector* FakeSyncManager::GetModelTypeConnector() {
-  return &fake_model_type_connector_;
-}
-
 std::unique_ptr<ModelTypeConnector>
 FakeSyncManager::GetModelTypeConnectorProxy() {
   return base::MakeUnique<FakeModelTypeConnector>();
 }
 
 const std::string FakeSyncManager::cache_guid() {
   return test_user_share_.user_share()->directory->cache_guid();
 }
 
 bool FakeSyncManager::ReceivedExperiment(Experiments* experiments) {
   return false;
 }
 
 bool FakeSyncManager::HasUnsyncedItems() {
   NOTIMPLEMENTED();
   return false;
 }
 
 SyncEncryptionHandler* FakeSyncManager::GetEncryptionHandler() {
-  return &fake_encryption_handler_;
+  return fake_encryption_handler_.get();
 }
 
 std::vector<std::unique_ptr<ProtocolEvent>>
 FakeSyncManager::GetBufferedProtocolEvents() {
   return std::vector<std::unique_ptr<ProtocolEvent>>();
 }
 
 void FakeSyncManager::RefreshTypes(ModelTypeSet types) {
   last_refresh_request_types_ = types;
 }
@@ skipping 30 matching lines @@
 }
 
 void FakeSyncManager::OnCookieJarChanged(bool account_mismatch,
                                          bool empty_jar) {}
 
 void FakeSyncManager::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace syncer