[Sync] - Implement isolated model association.

chrome/browser/sync/glue/model_association_manager.h

 // Copyright (c) 2012 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 CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__
 #define CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__
 #pragma once
 
 #include <list>
 
 #include "base/memory/weak_ptr.h"
+#include "base/timer.h"
 
 #include "chrome/browser/sync/glue/data_type_manager.h"
 
 namespace browser_sync {
 
 class DataTypeController;
 
 // |ModelAssociationManager| association functions are async. The results of
 // those operations are passed back via this interface.
 class ModelAssociationResultProcessor {
  public:
   virtual void OnModelAssociationDone(
       const DataTypeManager::ConfigureResult& result) = 0;
+
+  // when types (that did not complete loading, during the previous
+  // run of the configure) get loaded this callback is called to let the
+  // DTM know and request a reconfigure.
+  virtual void OnTypesLoaded() = 0;
 };
 
 // The class that is responsible for model association.
 class ModelAssociationManager {
  public:
   ModelAssociationManager(const DataTypeController::TypeMap* controllers,
                           ModelAssociationResultProcessor* processor);
   virtual ~ModelAssociationManager();
   // Initializes the state to do the model association in future. This
   // should be called before downloading the data. A subsequent call of
   // Initialize is only allowed when |OnModelAssociationDone|
   // has been called back from this class to the caller.

[tim (not reviewing), 2012/05/21 23:18:57]

I still don't really grok this comment.  "OnModelAssociationDone has been called
back from this class to the caller".  I think it should say 'after the
ModelAssociationManager has invoked OnModelAssociationDone on the
ModelAssociationResultProcessor.'

[lipalani1, 2012/05/22 01:23:58]

Done.

   void Initialize(syncable::ModelTypeSet desired_types);
 
   // Can be called at any time. Synchronously stops all datatypes.
   void Stop();
 
   // Should only be called after Initialize.
   // Starts the actual association. When this is completed
   // |OnModelAssociationDone| would be called on callback.
   void StartAssociationAsync();
 
   // It is valid to call this only when we are initialized to configure
   // but we have not started the configuration.(i.e., |Initialize| has
   // been called but |StartAssociationAsync| has not yet been called.)
   // If we have started configuration then the DTM will wait until
   // the current configuration is done before processing the reconfigure
   // request.
   void AbortConfigurationForReconfiguration();
 
   // Should only be called after Initialize.
   // Stops any disabled types.
   void StopDisabledTypes();
 
+  // This is used for TESTING PURPOSE ONLY. When invoked will
+  // simulate as though the timeout has been reached for datatype loading.
+  // Achieves that by stopping the timer and calling the timeout callback.
+  void TestSimulateDataTypeLoadTimeout();
+
  private:
   enum State {
     // This is the state after |Initialize| is called.
     INITIAILIZED_TO_CONFIGURE,
     // Starting a new configuration.
     CONFIGURING,
     // A stop command was issued.
     ABORT,
     // No configuration is in progress.
     IDLE
@@ skipping 13 matching lines @@
   // will be passed to |LoadModels| function.
   void ModelLoadCallback(syncable::ModelType type, SyncError error);
 
   // Calls the |LoadModels| method on the next controller waiting to start.
   void LoadModelForNextType();
 
   // Calls |StartAssociating| on the next available controller whose models are
   // loaded.
   void StartAssociatingNextType();
 
+  // We have waited long enough and the model has not loaded yet.
+  void ModelLoadTimedOut();
+
+  void HandleFailedTypes(DataTypeController::StartResult result,
+                         const SyncError& error);
+
+  syncable::ModelTypeSet GetTypesWaitingToLoad();
+
+
   State state_;
   syncable::ModelTypeSet desired_types_;
   std::list<SyncError> failed_datatypes_info_;
   std::map<syncable::ModelType, int> start_order_;
 
   // Controllers that need to be started during a config cycle.
   std::vector<DataTypeController*> needs_start_;
 
   // Controllers that need to be stopped during a config cycle.
   std::vector<DataTypeController*> needs_stop_;
 
   // Controllers whose |LoadModels| function has been invoked and that are
   // waiting for their models to be loaded. Cotrollers will be moved from
   // |needs_start_| to this list as their |LoadModels| method is invoked.
   std::vector<DataTypeController*> pending_model_load_;
 
   // Controllers whose models are loaded and are ready to do model
   // association. Controllers will be moved from |pending_model_load_|
   // list to this list as they finish loading their model.
   std::vector<DataTypeController*> waiting_to_associate_;
 
   // Controller currently doing model association.
   DataTypeController* currently_associating_;
 
   // Set of all registered controllers.
   const DataTypeController::TypeMap* controllers_;
   ModelAssociationResultProcessor* result_processor_;
   base::WeakPtrFactory<ModelAssociationManager> weak_ptr_factory_;
+  base::OneShotTimer<ModelAssociationManager> timer_;
 };
 }  // namespace browser_sync
 #endif  // CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__