[Sync] Switch bots to run integ tests for autofill as USS.

components/sync/driver/model_type_controller.cc

 // Copyright 2014 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/model_type_controller.h"
 
 #include <utility>
 
 #include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/bind_to_task_runner.h"
 #include "components/sync/base/data_type_histogram.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/engine/activation_context.h"
 #include "components/sync/engine/model_type_configurer.h"
 #include "components/sync/model/data_type_error_handler_impl.h"
 #include "components/sync/model/model_type_change_processor.h"
 #include "components/sync/model/model_type_debug_info.h"
 #include "components/sync/model/model_type_sync_bridge.h"
 #include "components/sync/model/sync_merge_result.h"
 
 namespace syncer {
 
+using BridgeProvider = ModelTypeController::BridgeProvider;
+using BridgeTask = ModelTypeController::BridgeTask;
+
 namespace {
 
-void CallOnSyncStartingHelper(
-    SyncClient* sync_client,
-    ModelType type,
+void OnSyncStartingHelper(
     const ModelErrorHandler& error_handler,
-    ModelTypeChangeProcessor::StartCallback callback) {
-  base::WeakPtr<ModelTypeSyncBridge> bridge =
-      sync_client->GetSyncBridgeForModelType(type);
-  if (bridge) {
-    bridge->OnSyncStarting(std::move(error_handler), callback);
-  }
-}
-
-void CallGetAllNodesHelper(SyncClient* sync_client,
-                           ModelType type,
-                           DataTypeController::AllNodesCallback callback) {
-  base::WeakPtr<ModelTypeSyncBridge> bridge =
-      sync_client->GetSyncBridgeForModelType(type);
-  if (bridge) {
-    ModelTypeDebugInfo::GetAllNodes(bridge, callback);
-  }
-}
-
-void CallGetStatusCountersHelper(
-    SyncClient* sync_client,
-    ModelType type,
-    const DataTypeController::StatusCountersCallback& callback) {
-  base::WeakPtr<ModelTypeSyncBridge> bridge =
-      sync_client->GetSyncBridgeForModelType(type);
-  if (bridge) {
-    ModelTypeDebugInfo::GetStatusCounters(bridge, callback);
-  }
-}
-
-void CallDisableSyncHelper(SyncClient* sync_client, ModelType type) {
-  base::WeakPtr<ModelTypeSyncBridge> bridge =
-      sync_client->GetSyncBridgeForModelType(type);
-  if (bridge) {
-    bridge->DisableSync();
-  }
+    const ModelTypeChangeProcessor::StartCallback& callback,
+    ModelTypeSyncBridge* bridge) {
+  bridge->OnSyncStarting(std::move(error_handler), std::move(callback));
 }
 
 void ReportError(ModelType model_type,
                  scoped_refptr<base::SingleThreadTaskRunner> ui_thread,
                  const ModelErrorHandler& error_handler,
                  const ModelError& error) {
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeRunFailures",
                             ModelTypeToHistogramInt(model_type),
                             MODEL_TYPE_COUNT);
   ui_thread->PostTask(error.location(), base::Bind(error_handler, error));
 }
 
+// This function allows us to return a Callback using Bind that returns the
+// given |arg|. This function itself does nothing.
+base::WeakPtr<ModelTypeSyncBridge> ReturnCapturedBridge(
+    base::WeakPtr<ModelTypeSyncBridge> arg) {
+  return arg;
+}
+
+void RunBridgeTask(const BridgeProvider& bridge_provider,
+                   const BridgeTask& task) {
+  if (base::WeakPtr<ModelTypeSyncBridge> bridge = bridge_provider.Run()) {
+    task.Run(bridge.get());
+  }
+}
+
 }  // namespace
 
 ModelTypeController::ModelTypeController(
     ModelType type,
     SyncClient* sync_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& model_thread)
     : DataTypeController(type),
       sync_client_(sync_client),
       model_thread_(model_thread),
       sync_prefs_(sync_client->GetPrefService()),
@@ skipping 28 matching lines @@
   ModelTypeChangeProcessor::StartCallback callback =
       BindToCurrentThread(base::Bind(&ModelTypeController::OnProcessorStarted,
                                      base::AsWeakPtr(this)));
 
   ModelErrorHandler error_handler = base::BindRepeating(
       &ReportError, type(), base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&ModelTypeController::ReportModelError,
                  base::AsWeakPtr(this)));
 
   // Start the type processor on the model thread.
-  model_thread_->PostTask(
-      FROM_HERE, base::Bind(&CallOnSyncStartingHelper, sync_client_, type(),
-                            std::move(error_handler), std::move(callback)));
+  PostBridgeTask(FROM_HERE,
+                 base::Bind(&OnSyncStartingHelper, std::move(error_handler),
+                            std::move(callback)));
 }
 
 void ModelTypeController::BeforeLoadModels(ModelTypeConfigurer* configurer) {}
 
 void ModelTypeController::LoadModelsDone(ConfigureResult result,
                                          const SyncError& error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ == NOT_RUNNING) {
     // The callback arrived on the UI thread after the type has been already
@@ skipping 80 matching lines @@
   if (state() == NOT_RUNNING)
     return;
 
   // Check preferences if datatype is not in preferred datatypes. Only call
   // DisableSync if the bridge is ready to handle it (controller is in loaded
   // state).
   ModelTypeSet preferred_types =
       sync_prefs_.GetPreferredDataTypes(ModelTypeSet(type()));
   if ((state() == MODEL_LOADED || state() == RUNNING) &&
       (!sync_prefs_.IsFirstSetupComplete() || !preferred_types.Has(type()))) {
-    model_thread_->PostTask(
-        FROM_HERE, base::Bind(&CallDisableSyncHelper, sync_client_, type()));
+    PostBridgeTask(FROM_HERE, base::Bind(&ModelTypeSyncBridge::DisableSync));
   }
 
   state_ = NOT_RUNNING;
 }
 
 std::string ModelTypeController::name() const {
   // For logging only.
   return ModelTypeToString(type());
 }
 
 DataTypeController::State ModelTypeController::state() const {
   return state_;
 }
 
 void ModelTypeController::GetAllNodes(const AllNodesCallback& callback) {
-  model_thread_->PostTask(
-      FROM_HERE, base::Bind(&CallGetAllNodesHelper, sync_client_, type(),
-                            BindToCurrentThread(callback)));
+  PostBridgeTask(FROM_HERE,
+                 base::Bind(&ModelTypeDebugInfo::GetAllNodes, callback));
 }
 
 void ModelTypeController::GetStatusCounters(
     const StatusCountersCallback& callback) {
-  model_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&CallGetStatusCountersHelper, sync_client_, type(), callback));
+  PostBridgeTask(FROM_HERE,
+                 base::Bind(&ModelTypeDebugInfo::GetStatusCounters, callback));
 }
 
 void ModelTypeController::ReportModelError(const ModelError& error) {
   DCHECK(CalledOnValidThread());
   LoadModelsDone(UNRECOVERABLE_ERROR,
                  SyncError(error.location(), SyncError::DATATYPE_ERROR,
                            error.message(), type()));
 }
 
 void ModelTypeController::RecordStartFailure(ConfigureResult result) const {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures",
                             ModelTypeToHistogramInt(type()), MODEL_TYPE_COUNT);
 #define PER_DATA_TYPE_MACRO(type_str)                                    \
   UMA_HISTOGRAM_ENUMERATION("Sync." type_str "ConfigureFailure", result, \
                             MAX_CONFIGURE_RESULT);
   SYNC_DATA_TYPE_HISTOGRAM(type());
 #undef PER_DATA_TYPE_MACRO
 }
 
+BridgeProvider ModelTypeController::GetBridgeProvider() {
+  // Get the bridge eagerly, and capture the weak pointer.
+  base::WeakPtr<ModelTypeSyncBridge> bridge =
+      sync_client_->GetSyncBridgeForModelType(type());
+  return base::Bind(&ReturnCapturedBridge, bridge);
+}
+
+void ModelTypeController::PostBridgeTask(
+    const tracked_objects::Location& location,
+    const BridgeTask& task) {
+  model_thread_->PostTask(
+      location, base::Bind(&RunBridgeTask, GetBridgeProvider(), task));
+}
 }  // namespace syncer