[Sync] Make directory types registration explicit in ModelTypeRegistry

components/sync/driver/glue/sync_backend_host_impl.cc

 // Copyright 2013 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_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 72 matching lines @@
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_, types));
 }
 
 void SyncBackendHostImpl::UpdateCredentials(
     const SyncCredentials& credentials) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoUpdateCredentials, core_,
                             credentials));
 }
 
+void SyncBackendHostImpl::StartConfiguration() {
+  sync_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoStartConfiguration, core_));
+}
+
 void SyncBackendHostImpl::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHostImpl::StartSyncingWithServer called.";
 
-  ModelSafeRoutingInfo routing_info;
-  registrar_->GetModelSafeRoutingInfo(&routing_info);
-
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoStartSyncing, core_,
-                            routing_info, sync_prefs_->GetLastPollTime()));
+                            sync_prefs_->GetLastPollTime()));
 }
 
 void SyncBackendHostImpl::SetEncryptionPassphrase(const std::string& passphrase,
                                                   bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return;
@@ skipping 92 matching lines @@
 void SyncBackendHostImpl::ConfigureDataTypes(ConfigureParams params) {
   sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoPurgeDisabledTypes, core_,
                  params.to_purge, params.to_journal, params.to_unapply));
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_,
                             base::Passed(&params)));
 }
 
+void SyncBackendHostImpl::RegisterDirectoryDataType(ModelType type,
+                                                    ModelSafeGroup group) {
+  model_type_connector_->RegisterDirectoryType(type, group);
+}
+
+void SyncBackendHostImpl::UnregisterDirectoryDataType(ModelType type) {
+  model_type_connector_->UnregisterDirectoryType(type);
+}
+
 void SyncBackendHostImpl::EnableEncryptEverything() {
   sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoEnableEncryptEverything, core_));
 }
 
 void SyncBackendHostImpl::ActivateDirectoryDataType(
     ModelType type,
     ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHostImpl::DeactivateDirectoryDataType(ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
 void SyncBackendHostImpl::ActivateNonBlockingDataType(
     ModelType type,
     std::unique_ptr<ActivationContext> activation_context) {
   registrar_->RegisterNonBlockingType(type);
   if (activation_context->model_type_state.initial_sync_done())
     registrar_->AddRestoredNonBlockingType(type);
-  model_type_connector_->ConnectType(type, std::move(activation_context));
+  model_type_connector_->ConnectNonBlockingType(type,
+                                                std::move(activation_context));
 }
 
 void SyncBackendHostImpl::DeactivateNonBlockingDataType(ModelType type) {
-  model_type_connector_->DisconnectType(type);
+  model_type_connector_->DisconnectNonBlockingType(type);
 }
 
 UserShare* SyncBackendHostImpl::GetUserShare() const {
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHostImpl::Status SyncBackendHostImpl::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
@@ skipping 305 matching lines @@
     const SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG