[Sync] Make directory types registration explicit in ModelTypeRegistry

components/sync/driver/glue/sync_backend_host_core.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_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 123 matching lines @@
   // which we initialize below to ensure that we don't perform any downloads if
   // all control types have already completed their initial sync.
   registrar_->SetInitialTypes(restored_types);
 
   ConfigureReason reason = restored_types.Empty()
                                ? CONFIGURE_REASON_NEW_CLIENT
                                : CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
 
   ModelTypeSet new_control_types =
       registrar_->ConfigureDataTypes(ControlTypes(), ModelTypeSet());
+
+  // Control types don't have DataTypeControllers, but they need to have
+  // update handlers registerd in ModelTypeRegistry. Register them here.

[maxbogue, 2017/01/18 01:24:11]

registered

[pavely, 2017/01/18 20:18:07]

Done.

+  auto model_type_connector = sync_manager_->GetModelTypeConnectorProxy();

[maxbogue, 2017/01/18 01:24:11]

I think you should probably just have an accessor for ModelTypeRegistry* (or
ModelTypeConnector*) on SyncManager. This is creating a whole new proxy object
and the RegisterDirectoryType call will be asynchronous because of it, neither
of which are necessary.

[pavely, 2017/01/18 20:18:07]

Done.

+  ModelTypeSet control_types = ControlTypes();
+  for (auto it = control_types.First(); it.Good(); it.Inc()) {
+    model_type_connector->RegisterDirectoryType(it.Get(), GROUP_PASSIVE);
+  }
+
   ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   SDVLOG(1) << "Control Types " << ModelTypeSetToString(new_control_types)
             << " added; calling ConfigureSyncer";
 
   ModelTypeSet types_to_purge =
       Difference(ModelTypeSet::All(), GetRoutingInfoTypes(routing_info));
 
   sync_manager_->PurgeDisabledTypes(types_to_purge, ModelTypeSet(),
                                     ModelTypeSet());
   sync_manager_->ConfigureSyncer(
-      reason, new_control_types, routing_info,
+      reason, new_control_types,
       base::Bind(&SyncBackendHostCore::DoInitialProcessControlTypes,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Closure());
 }
 
 void SyncBackendHostCore::OnConnectionStatusChange(ConnectionStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop,
              status);
@@ skipping 216 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   // UpdateCredentials can be called during backend initialization, possibly
   // when backend initialization has failed but hasn't notified the UI thread
   // yet. In that case, the sync manager may have been destroyed on the sync
   // thread before this task was executed, so we do nothing.
   if (sync_manager_) {
     sync_manager_->UpdateCredentials(credentials);
   }
 }
 
-void SyncBackendHostCore::DoStartSyncing(
-    const ModelSafeRoutingInfo& routing_info,
-    base::Time last_poll_time) {
+void SyncBackendHostCore::DoStartConfiguration() {
+  sync_manager_->StartConfiguration();
+}
+
+void SyncBackendHostCore::DoStartSyncing(base::Time last_poll_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  sync_manager_->StartSyncingNormally(routing_info, last_poll_time);
+  sync_manager_->StartSyncingNormally(last_poll_time);
 }
 
 void SyncBackendHostCore::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
                                                                  is_explicit);
 }
 
@@ skipping 101 matching lines @@
 }
 
 void SyncBackendHostCore::DoConfigureSyncer(
     ModelTypeConfigurer::ConfigureParams params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!params.ready_task.is_null());
   DCHECK(!params.retry_callback.is_null());
 
   registrar_->ConfigureDataTypes(params.enabled_types, params.disabled_types);
 
-  ModelSafeRoutingInfo routing_info;
-  registrar_->GetModelSafeRoutingInfo(&routing_info);
-
   base::Closure chained_ready_task(base::Bind(
       &SyncBackendHostCore::DoFinishConfigureDataTypes,
       weak_ptr_factory_.GetWeakPtr(), params.to_download, params.ready_task));
   base::Closure chained_retry_task(
       base::Bind(&SyncBackendHostCore::DoRetryConfiguration,
                  weak_ptr_factory_.GetWeakPtr(), params.retry_callback));
 
   sync_manager_->ConfigureSyncer(params.reason, params.to_download,
-                                 routing_info, chained_ready_task,
-                                 chained_retry_task);
+                                 chained_ready_task, chained_retry_task);
 }
 
 void SyncBackendHostCore::DoFinishConfigureDataTypes(
     ModelTypeSet types_to_config,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update the enabled types for the bridge and sync manager.
   ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
@@ skipping 95 matching lines @@
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 }  // namespace syncer