Revert 288464 "[Sync] Cleanup datatype configuration error handl..."

trunk/src/components/sync_driver/model_association_manager.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_DRIVER_MODEL_ASSOCIATION_MANAGER_H__
 #define COMPONENTS_SYNC_DRIVER_MODEL_ASSOCIATION_MANAGER_H__
 
 #include <map>
 
 #include "base/memory/weak_ptr.h"
@@ skipping 18 matching lines @@
  public:
   // Called when model association (MergeDataAndStartSyncing) has completed
   // for |type|, regardless of success or failure.
   virtual void OnSingleDataTypeAssociationDone(
       syncer::ModelType type,
       const syncer::DataTypeAssociationStats& association_stats) = 0;
 
   // Called when the ModelAssociationManager has decided it must stop |type|,
   // likely because it is no longer a desired data type or sync is shutting
   // down.
-  virtual void OnSingleDataTypeWillStop(syncer::ModelType type,
-                                        const syncer::SyncError& error) = 0;
+  virtual void OnSingleDataTypeWillStop(syncer::ModelType type) = 0;
 
   // Called when the ModelAssociationManager has tried to perform model
   // association for all desired types and has nothing left to do.
   virtual void OnModelAssociationDone(
       const DataTypeManager::ConfigureResult& result) = 0;
   virtual ~ModelAssociationManagerDelegate() {}
 };
 
 // The class that is responsible for model association.
 class ModelAssociationManager {
@@ skipping 41 matching lines @@
   // Called by Initialize() to stop types that are not in |desired_types_|.
   void StopDisabledTypes();
 
   // Start loading non-running types that are in |desired_types_|.
   void LoadEnabledTypes();
 
   // Callback passed to each data type controller on starting association. This
   // callback will be invoked when the model association is done.
   void TypeStartCallback(syncer::ModelType type,
                          base::TimeTicks type_start_time,
-                         DataTypeController::ConfigureResult start_result,
+                         DataTypeController::StartResult start_result,
                          const syncer::SyncMergeResult& local_merge_result,
                          const syncer::SyncMergeResult& syncer_merge_result);
 
   // Callback that will be invoked when the models finish loading. This callback
   // will be passed to |LoadModels| function.
   void ModelLoadCallback(syncer::ModelType type, syncer::SyncError error);
 
+  // When a type fails to load or fails associating this method is invoked to
+  // do the book keeping and do the UMA reporting.
+  void AppendToFailedDatatypesAndLogError(const syncer::SyncError& error);
+
   // Called when all requested types are associated or association times out.
   // Notify |delegate_| of configuration results.
   void ModelAssociationDone();
 
   // A helper to stop an individual datatype.
-  void StopDatatype(const syncer::SyncError& error, DataTypeController* dtc);
+  void StopDatatype(DataTypeController* dtc);
 
   State state_;
 
   // Data types that are enabled.
   syncer::ModelTypeSet desired_types_;
 
   // Data types that are requested to associate.
   syncer::ModelTypeSet requested_types_;
 
   // Data types currently being associated, including types waiting for model
   // load.
   syncer::ModelTypeSet associating_types_;
 
   // Data types that are loaded, i.e. ready to associate.
   syncer::ModelTypeSet loaded_types_;
 
   // Data types that are associated, i.e. no more action needed during
   // reconfiguration if not disabled.
   syncer::ModelTypeSet associated_types_;
 
+  // Data types that are still loading/associating when configuration times
+  // out.
+  syncer::ModelTypeSet slow_types_;
+
+  // Collects the list of errors resulting from failing to start a type. This
+  // would eventually be sent to the listeners after all the types have
+  // been given a chance to start.
+  std::map<syncer::ModelType, syncer::SyncError> failed_data_types_info_;
+
+  // The set of types that can't configure due to cryptographer errors.
+  syncer::ModelTypeSet needs_crypto_types_;
+
   // Time when StartAssociationAsync() is called to associate for a set of data
   // types.
   base::TimeTicks association_start_time_;
 
   // Set of all registered controllers.
   const DataTypeController::TypeMap* controllers_;
 
   // The processor in charge of handling model association results.
   ModelAssociationManagerDelegate* delegate_;
 
   // Timer to track and limit how long a datatype takes to model associate.
   base::OneShotTimer<ModelAssociationManager> timer_;
 
   base::WeakPtrFactory<ModelAssociationManager> weak_ptr_factory_;
 
   DataTypeManager::ConfigureStatus configure_status_;
 
   DISALLOW_COPY_AND_ASSIGN(ModelAssociationManager);
 };
 
 }  // namespace sync_driver
 
 #endif  // COMPONENTS_SYNC_DRIVER_MODEL_ASSOCIATION_MANAGER_H__