sync: cut a few profile deps from DataTypeControllers.

components/sync_driver/model_association_manager.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_association_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
@@ skipping 92 matching lines @@
       syncer_merge_result.pre_association_version();
   stats.association_wait_time = association_wait_time;
   stats.association_time = association_time;
   return stats;
 }
 
 }  // namespace
 
 ModelAssociationManager::ModelAssociationManager(
     const DataTypeController::TypeMap* controllers,
-    ModelAssociationResultProcessor* processor)
+    ModelAssociationManagerDelegate* processor)
     : state_(IDLE),
       controllers_(controllers),
-      result_processor_(processor),
+      delegate_(processor),
       weak_ptr_factory_(this),
       configure_status_(DataTypeManager::UNKNOWN) {
   // Ensure all data type controllers are stopped.
   for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
        it != controllers_->end(); ++it) {
     DCHECK_EQ(DataTypeController::NOT_RUNNING, (*it).second->state());
   }
 }
 
 ModelAssociationManager::~ModelAssociationManager() {
@@ skipping 16 matching lines @@
 
   DVLOG(1) << "ModelAssociationManager: Initializing for "
            << syncer::ModelTypeSetToString(desired_types_);
 
   state_ = INITIALIZED_TO_CONFIGURE;
 
   StopDisabledTypes();
   LoadEnabledTypes();
 }
 
+void ModelAssociationManager::StopDatatype(DataTypeController* dtc) {
+  // First tell the sync backend that we no longer want to listen to
+  // changes for this type.
+  delegate_->OnSingleDataTypeWillStop(dtc->type());
+
+  // Then tell all data type specific logic to shut down.
+  dtc->Stop();
+}
+
 void ModelAssociationManager::StopDisabledTypes() {
   DVLOG(1) << "ModelAssociationManager: Stopping disabled types.";
   for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
        it != controllers_->end(); ++it) {
     DataTypeController* dtc = (*it).second.get();
     if (dtc->state() != DataTypeController::NOT_RUNNING &&
         (!desired_types_.Has(dtc->type()) ||
             failed_data_types_info_.count(dtc->type()) > 0)) {
       DVLOG(1) << "ModelTypeToString: stop " << dtc->name();
-      dtc->Stop();
-
+      StopDatatype(dtc);
       loaded_types_.Remove(dtc->type());
       associated_types_.Remove(dtc->type());
     }
   }
 }
 
 void ModelAssociationManager::LoadEnabledTypes() {
   // Load in kStartOrder.
   for (size_t i = 0; i < arraysize(kStartOrder); i++) {
     syncer::ModelType type = kStartOrder[i];
@@ skipping 80 matching lines @@
 
 void ModelAssociationManager::Stop() {
   // Ignore callbacks from controllers.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Stop started data types.
   for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
        it != controllers_->end(); ++it) {
     DataTypeController* dtc = (*it).second.get();
     if (dtc->state() != DataTypeController::NOT_RUNNING) {
-      dtc->Stop();
+      StopDatatype(dtc);
       DVLOG(1) << "ModelAssociationManager: Stopped " << dtc->name();
     }
   }
 
   desired_types_.Clear();
   loaded_types_.Clear();
   associated_types_.Clear();
   slow_types_.Clear();
 
   if (state_ == CONFIGURING) {
@@ skipping 71 matching lines @@
 
   DCHECK(!associated_types_.Has(type));
   if (DataTypeController::IsSuccessfulResult(start_result)) {
     associated_types_.Put(type);
   } else if (state_ == IDLE) {
     // For type that failed in IDLE mode, simply stop the controller. Next
     // configuration will try to restart from scratch if the type is still
     // enabled.
     DataTypeController* dtc = controllers_->find(type)->second.get();
     if (dtc->state() != DataTypeController::NOT_RUNNING)
-      dtc->Stop();
+      StopDatatype(dtc);
     loaded_types_.Remove(type);
   } else {
     // Record error in CONFIGURING or INITIALIZED_TO_CONFIGURE mode. The error
     // will be reported when data types association finishes.
     if (start_result == DataTypeController::NEEDS_CRYPTO) {
       DVLOG(1) << "ModelAssociationManager: Encountered an undecryptable type";
       needs_crypto_types_.Put(type);
     } else {
       DVLOG(1) << "ModelAssociationManager: Encountered a failed type";
       AppendToFailedDatatypesAndLogError(local_merge_result.error());
@@ skipping 15 matching lines @@
       syncer::ProtocolTypes().Has(type)) {
     base::TimeDelta association_wait_time =
         std::max(base::TimeDelta(), type_start_time - association_start_time_);
     base::TimeDelta association_time =
         base::TimeTicks::Now() - type_start_time;;
     syncer::DataTypeAssociationStats stats =
         BuildAssociationStatsFromMergeResults(local_merge_result,
                                               syncer_merge_result,
                                               association_wait_time,
                                               association_time);
-    result_processor_->OnSingleDataTypeAssociationDone(type, stats);
+    delegate_->OnSingleDataTypeAssociationDone(type, stats);
   }
 
   // Update configuration result.
   if (configure_status_ == DataTypeManager::OK &&
       start_result == DataTypeController::ASSOCIATION_FAILED) {
     configure_status_ = DataTypeManager::PARTIAL_SUCCESS;
   }
   if (start_result == DataTypeController::UNRECOVERABLE_ERROR)
     configure_status_ = DataTypeManager::UNRECOVERABLE_ERROR;
 
@@ skipping 30 matching lines @@
     DVLOG(1) << "ModelAssociationManager: setting partial success";
     configure_status_ = DataTypeManager::PARTIAL_SUCCESS;
   }
 
   DataTypeManager::ConfigureResult result(configure_status_,
                                           requested_types_,
                                           failed_data_types_info_,
                                           associating_types_,
                                           needs_crypto_types_);
 
-  // Reset state before notifying |result_processor_| because that might
+  // Reset state before notifying |delegate_| because that might
   // trigger a new round of configuration.
   ResetForNextAssociation();
   state_ = IDLE;
 
-  result_processor_->OnModelAssociationDone(result);
+  delegate_->OnModelAssociationDone(result);
 }
 
 base::OneShotTimer<ModelAssociationManager>*
     ModelAssociationManager::GetTimerForTesting() {
   return &timer_;
 }
 
 }  // namespace browser_sync