[Sync] Make directory types registration explicit in ModelTypeRegistry

components/sync/engine_impl/sync_manager_impl.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_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 164 matching lines @@
 
     if (marker.token().empty())
       result.Put(i.Get());
   }
   return result;
 }
 
 void SyncManagerImpl::ConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
-    const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!ready_task.is_null());
   DCHECK(initialized_);
 
   // Don't download non-blocking types that have already completed initial sync.
   to_download.RemoveAll(
       model_type_registry_->GetInitialSyncDoneNonBlockingTypes());
 
   DVLOG(1) << "Configuring -"
            << "\n\t"
-           << "current types: "
-           << ModelTypeSetToString(GetRoutingInfoTypes(new_routing_info))
-           << "\n\t"
            << "types to download: " << ModelTypeSetToString(to_download);
   ConfigurationParams params(GetSourceFromReason(reason), to_download,
-                             new_routing_info, ready_task, retry_task);
+                             ready_task, retry_task);
 
   scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
   scheduler_->ScheduleConfiguration(params);
 }
 
 void SyncManagerImpl::Init(InitArgs* args) {
   CHECK(!initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(args->post_factory.get());
   if (!args->enable_local_sync_backend) {
@@ skipping 175 matching lines @@
     base::Time explicit_passphrase_time) {
   allstatus_.SetPassphraseType(type);
   allstatus_.SetKeystoreMigrationTime(
       sync_encryption_handler_->migration_time());
 }
 
 void SyncManagerImpl::OnLocalSetPassphraseEncryption(
     const SyncEncryptionHandler::NigoriState& nigori_state) {}
 
 void SyncManagerImpl::StartSyncingNormally(
-    const ModelSafeRoutingInfo& routing_info,
     base::Time last_poll_time) {
   // Start the sync scheduler.
-  // TODO(sync): We always want the newest set of routes when we switch back
-  // to normal mode. Figure out how to enforce set_routing_info is always
-  // appropriately set and that it's only modified when switching to normal
-  // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
-  cycle_context_->SetRoutingInfo(routing_info);
   scheduler_->Start(SyncScheduler::NORMAL_MODE, last_poll_time);
 }
 
+void SyncManagerImpl::StartConfiguration() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
+}
+
 syncable::Directory* SyncManagerImpl::directory() {
   return share_.directory.get();
 }
 
 const SyncScheduler* SyncManagerImpl::scheduler() const {
   return scheduler_.get();
 }
 
 bool SyncManagerImpl::GetHasInvalidAuthTokenForTest() const {
   return connection_manager_->HasInvalidAuthToken();
@@ skipping 478 matching lines @@
 
 void SyncManagerImpl::SaveChanges() {
   directory()->SaveChanges();
 }
 
 UserShare* SyncManagerImpl::GetUserShare() {
   DCHECK(initialized_);
   return &share_;
 }
 
+ModelTypeConnector* SyncManagerImpl::GetModelTypeConnector() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return model_type_registry_.get();
+}
+
 std::unique_ptr<ModelTypeConnector>
 SyncManagerImpl::GetModelTypeConnectorProxy() {
   DCHECK(initialized_);
   return base::MakeUnique<ModelTypeConnectorProxy>(
       base::ThreadTaskRunnerHandle::Get(), model_type_registry_->AsWeakPtr());
 }
 
 const std::string SyncManagerImpl::cache_guid() {
   DCHECK(initialized_);
   return directory()->cache_guid();
@@ skipping 88 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   cycle_context_->set_cookie_jar_mismatch(account_mismatch);
   cycle_context_->set_cookie_jar_empty(empty_jar);
 }
 
 void SyncManagerImpl::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
   directory()->OnMemoryDump(pmd);
 }
 
 }  // namespace syncer