src/components/sync_driver/data_type_manager_impl.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_SYNC_DRIVER_DATA_TYPE_MANAGER_IMPL_H__
   6 #define COMPONENTS_SYNC_DRIVER_DATA_TYPE_MANAGER_IMPL_H__
   7
   8 #include "components/sync_driver/data_type_manager.h"
   9
  10 #include <map>
  11 #include <queue>
  12 #include <vector>
  13
  14 #include "base/basictypes.h"
  15 #include "base/callback_forward.h"
  16 #include "base/compiler_specific.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/time/time.h"
  19 #include "components/sync_driver/backend_data_type_configurer.h"
  20 #include "components/sync_driver/model_association_manager.h"
  21
  22 namespace syncer {
  23 struct DataTypeConfigurationStats;
  24 class DataTypeDebugInfoListener;
  25 template <typename T> class WeakHandle;
  26 }
  27
  28 namespace browser_sync {
  29
  30 class DataTypeController;
  31 class DataTypeEncryptionHandler;
  32 class DataTypeManagerObserver;
  33 class FailedDataTypesHandler;
  34
  35 // List of data types grouped by priority and ordered from high priority to
  36 // low priority.
  37 typedef std::queue<syncer::ModelTypeSet> TypeSetPriorityList;
  38
  39 class DataTypeManagerImpl : public DataTypeManager,
  40                             public ModelAssociationManagerDelegate {
  41  public:
  42   DataTypeManagerImpl(
  43       const base::Closure& unrecoverable_error_method,
  44       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
  45           debug_info_listener,
  46       const DataTypeController::TypeMap* controllers,
  47       const DataTypeEncryptionHandler* encryption_handler,
  48       BackendDataTypeConfigurer* configurer,
  49       DataTypeManagerObserver* observer,
  50       FailedDataTypesHandler* failed_data_types_handler);
  51   virtual ~DataTypeManagerImpl();
  52
  53   // DataTypeManager interface.
  54   virtual void Configure(syncer::ModelTypeSet desired_types,
  55                          syncer::ConfigureReason reason) OVERRIDE;
  56
  57   // Needed only for backend migration.
  58   virtual void PurgeForMigration(
  59       syncer::ModelTypeSet undesired_types,
  60       syncer::ConfigureReason reason) OVERRIDE;
  61
  62   virtual void Stop() OVERRIDE;
  63   virtual State state() const OVERRIDE;
  64
  65   // |ModelAssociationManagerDelegate| implementation.
  66   virtual void OnSingleDataTypeAssociationDone(
  67       syncer::ModelType type,
  68       const syncer::DataTypeAssociationStats& association_stats) OVERRIDE;
  69   virtual void OnModelAssociationDone(
  70       const DataTypeManager::ConfigureResult& result) OVERRIDE;
  71   virtual void OnSingleDataTypeWillStop(syncer::ModelType type) OVERRIDE;
  72
  73   // Used by unit tests. TODO(sync) : This would go away if we made
  74   // this class be able to do Dependency injection. crbug.com/129212.
  75   ModelAssociationManager* GetModelAssociationManagerForTesting() {
  76     return &model_association_manager_;
  77   }
  78
  79  private:
  80   friend class TestDataTypeManager;
  81
  82   // Abort configuration and stop all data types due to configuration errors.
  83   void Abort(ConfigureStatus status,
  84              const syncer::SyncError& error);
  85
  86   // Returns the priority types (control + priority user types).
  87   // Virtual for overriding during tests.
  88   virtual syncer::ModelTypeSet GetPriorityTypes() const;
  89
  90   // Divide |types| into sets by their priorities and return the sets from
  91   // high priority to low priority.
  92   TypeSetPriorityList PrioritizeTypes(const syncer::ModelTypeSet& types);
  93
  94   // Post a task to reconfigure when no downloading or association are running.
  95   void ProcessReconfigure();
  96
  97   void Restart(syncer::ConfigureReason reason);
  98   void DownloadReady(base::Time download_start_time,
  99                      syncer::ModelTypeSet types_to_download,
 100                      syncer::ModelTypeSet high_priority_types_before,
 101                      syncer::ModelTypeSet first_sync_types,
 102                      syncer::ModelTypeSet failed_configuration_types);
 103
 104   // Notification from the SBH that download failed due to a transient
 105   // error and it will be retried.
 106   void OnDownloadRetry();
 107   void NotifyStart();
 108   void NotifyDone(const ConfigureResult& result);
 109
 110   // Add to |configure_time_delta_| the time since we last called
 111   // Restart().
 112   void AddToConfigureTime();
 113
 114   void ConfigureImpl(syncer::ModelTypeSet desired_types,
 115                      syncer::ConfigureReason reason);
 116
 117   BackendDataTypeConfigurer::DataTypeConfigStateMap
 118   BuildDataTypeConfigStateMap(
 119       const syncer::ModelTypeSet& types_being_configured) const;
 120
 121   // Start association of next batch of data types after association of
 122   // previous batch finishes.
 123   void StartNextAssociation();
 124
 125   void StopImpl();
 126
 127   BackendDataTypeConfigurer* configurer_;
 128   // Map of all data type controllers that are available for sync.
 129   // This list is determined at startup by various command line flags.
 130   const DataTypeController::TypeMap* controllers_;
 131   State state_;
 132   std::map<syncer::ModelType, int> start_order_;
 133   syncer::ModelTypeSet last_requested_types_;
 134
 135   // Whether an attempt to reconfigure was made while we were busy configuring.
 136   // The |last_requested_types_| will reflect the newest set of requested types.
 137   bool needs_reconfigure_;
 138
 139   // The reason for the last reconfigure attempt. Note: this will be set to a
 140   // valid value only when |needs_reconfigure_| is set.
 141   syncer::ConfigureReason last_configure_reason_;
 142
 143   // The last time Restart() was called.
 144   base::Time last_restart_time_;
 145
 146   // The accumulated time spent between calls to Restart() and going
 147   // to the DONE state.
 148   base::TimeDelta configure_time_delta_;
 149
 150   // Sync's datatype debug info listener, which we pass model association
 151   // statistics to.
 152   const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
 153       debug_info_listener_;
 154
 155   // The manager that handles the model association of the individual types.
 156   ModelAssociationManager model_association_manager_;
 157
 158   // DataTypeManager must have only one observer -- the ProfileSyncService that
 159   // created it and manages its lifetime.
 160   DataTypeManagerObserver* const observer_;
 161
 162   // For querying failed data types (having unrecoverable error) when
 163   // configuring backend.
 164   browser_sync::FailedDataTypesHandler* failed_data_types_handler_;
 165
 166   // Types waiting to be downloaded.
 167   TypeSetPriorityList download_types_queue_;
 168
 169   // Types waiting for association and related time tracking info.
 170   struct AssociationTypesInfo {
 171     AssociationTypesInfo();
 172     ~AssociationTypesInfo();
 173     syncer::ModelTypeSet types;
 174     syncer::ModelTypeSet first_sync_types;
 175     base::Time download_start_time;
 176     base::Time download_ready_time;
 177     base::Time association_request_time;
 178     syncer::ModelTypeSet high_priority_types_before;
 179     syncer::ModelTypeSet configured_types;
 180   };
 181   std::queue<AssociationTypesInfo> association_types_queue_;
 182
 183   // The encryption handler lets the DataTypeManager know the state of sync
 184   // datatype encryption.
 185   const browser_sync::DataTypeEncryptionHandler* encryption_handler_;
 186
 187   // Association and time stats of data type configuration.
 188   std::vector<syncer::DataTypeConfigurationStats> configuration_stats_;
 189
 190   base::Closure unrecoverable_error_method_;
 191
 192   base::WeakPtrFactory<DataTypeManagerImpl> weak_ptr_factory_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(DataTypeManagerImpl);
 195 };
 196
 197 }  // namespace browser_sync
 198
 199 #endif  // COMPONENTS_SYNC_DRIVER_DATA_TYPE_MANAGER_IMPL_H__