[CrOS Sync] Allow transport in SyncableServiceBasedModelTypeController.

This CL adds the ability to sync in transport mode via
SyncableServiceBasedModelTypeController. A follow-up CL converts
SupervisedUserSyncModelTypeController to use transport mode.

Bug: 1030454, 1043755
Change-Id: I6a49de5d8d5dd9c24422456fbdbc56683e64c002
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2016195
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Mikel Astiz <mastiz@chromium.org>
Reviewed-by: Marc Treib <treib@chromium.org>
Cr-Commit-Position: refs/heads/master@{#736243}

components/sync/driver/syncable_service_based_model_type_controller.cc

@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "components/sync/model_impl/client_tag_based_model_type_processor.h"
+#include "components/sync/model_impl/forwarding_model_type_controller_delegate.h"
 #include "components/sync/model_impl/syncable_service_based_bridge.h"
 
 namespace syncer {
@@ -79,15 +80,33 @@ SyncableServiceBasedModelTypeController::
         ModelType type,
         OnceModelTypeStoreFactory store_factory,
         base::WeakPtr<SyncableService> syncable_service,
-        const base::RepeatingClosure& dump_stack)
-    : ModelTypeController(
-          type,
-          std::make_unique<ControllerDelegate>(type,
-                                               std::move(store_factory),
-                                               syncable_service,
-                                               dump_stack)) {}
+        const base::RepeatingClosure& dump_stack,
+        DelegateMode delegate_mode)
+    : ModelTypeController(type),
+      delegate_(std::make_unique<ControllerDelegate>(type,
+                                                     std::move(store_factory),
+                                                     syncable_service,
+                                                     dump_stack)) {
+  // Delegate for full sync is always created.
+  auto full_sync_delegate =
+      std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
+          delegate_.get());
+
+  // Delegate for transport is only created if requested and left null
+  // otherwise.
+  std::unique_ptr<syncer::ForwardingModelTypeControllerDelegate>
+      transport_delegate;
+  if (delegate_mode == DelegateMode::kTransportModeWithSingleModel) {
+    transport_delegate =
+        std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
+            delegate_.get());
+  }
+
+  InitModelTypeController(std::move(full_sync_delegate),
+                          std::move(transport_delegate));
+}
 
 SyncableServiceBasedModelTypeController::
-    ~SyncableServiceBasedModelTypeController() {}
+    ~SyncableServiceBasedModelTypeController() = default;
 
 }  // namespace syncer

components/sync/driver/syncable_service_based_model_type_controller.h

@@ -5,6 +5,8 @@
 #ifndef COMPONENTS_SYNC_DRIVER_SYNCABLE_SERVICE_BASED_MODEL_TYPE_CONTROLLER_H_
 #define COMPONENTS_SYNC_DRIVER_SYNCABLE_SERVICE_BASED_MODEL_TYPE_CONTROLLER_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "components/sync/base/model_type.h"
@@ -19,15 +21,25 @@ class SyncableService;
 // a non-blocking datatype (USS), for datatypes living in the UI thread.
 class SyncableServiceBasedModelTypeController : public ModelTypeController {
  public:
-  // |syncable_service| may be null in tests.
+  enum class DelegateMode { kFullSyncModeOnly, kTransportModeWithSingleModel };
+
+  // |syncable_service| may be null in tests. If |use_transport_mode| is true,
+  // two delegates are created: one for full sync and one for transport only.
+  // Otherwise, only the full sync delegate is created.
   SyncableServiceBasedModelTypeController(
       ModelType type,
       OnceModelTypeStoreFactory store_factory,
       base::WeakPtr<SyncableService> syncable_service,
-      const base::RepeatingClosure& dump_stack);
+      const base::RepeatingClosure& dump_stack,
+      DelegateMode delegate_mode = DelegateMode::kFullSyncModeOnly);
+
   ~SyncableServiceBasedModelTypeController() override;
 
  private:
+  // Delegate owned by this instance; delegate instances passed to the base
+  // class forward their calls to |delegate_|.
+  std::unique_ptr<ModelTypeControllerDelegate> delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncableServiceBasedModelTypeController);
 };