src/chrome/browser/sync/profile_sync_components_factory.h

   1 // Copyright (c) 2012 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 CHROME_BROWSER_SYNC_PROFILE_SYNC_COMPONENTS_FACTORY_H__
   6 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_COMPONENTS_FACTORY_H__
   7
   8 #include <string>
   9
  10 #include "base/files/file_path.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "components/invalidation/invalidation_service.h"
  13 #include "components/sync_driver/data_type_controller.h"
  14 #include "components/sync_driver/data_type_error_handler.h"
  15 #include "components/sync_driver/sync_api_component_factory.h"
  16 #include "sync/api/sync_merge_result.h"
  17 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
  18 #include "sync/internal_api/public/util/weak_handle.h"
  19
  20 class PasswordStore;
  21 class Profile;
  22 class ProfileSyncService;
  23
  24 namespace browser_sync {
  25 class LocalDeviceInfoProvider;
  26 class SyncBackendHost;
  27 }  // namespace browser_sync
  28
  29 namespace sync_driver {
  30 class AssociatorInterface;
  31 class ChangeProcessor;
  32 class DataTypeEncryptionHandler;
  33 class DataTypeErrorHandler;
  34 class DataTypeManager;
  35 class DataTypeManagerObserver;
  36 class FailedDataTypesHandler;
  37 class GenericChangeProcessor;
  38 class SyncPrefs;
  39 }  // namespace sync_driver
  40
  41 namespace syncer {
  42 class DataTypeDebugInfoListener;
  43 class SyncableService;
  44 }  // namespace syncer
  45
  46 namespace history {
  47 class HistoryBackend;
  48 }  // namespace history
  49
  50 // Factory class for all profile sync related classes.
  51 class ProfileSyncComponentsFactory
  52     : public sync_driver::SyncApiComponentFactory {
  53  public:
  54   // The various factory methods for the data type model associators
  55   // and change processors all return this struct.  This is needed
  56   // because the change processors typically require a type-specific
  57   // model associator at construction time.
  58   //
  59   // Note: This interface is deprecated in favor of the SyncableService API.
  60   // New datatypes that do not live on the UI thread should directly return a
  61   // weak pointer to a syncer::SyncableService. All others continue to return
  62   // SyncComponents. It is safe to assume that the factory methods below are
  63   // called on the same thread in which the datatype resides.
  64   //
  65   // TODO(zea): Have all datatypes using the new API switch to returning
  66   // SyncableService weak pointers instead of SyncComponents (crbug.com/100114).
  67   struct SyncComponents {
  68     sync_driver::AssociatorInterface* model_associator;
  69     sync_driver::ChangeProcessor* change_processor;
  70     SyncComponents(sync_driver::AssociatorInterface* ma,
  71                    sync_driver::ChangeProcessor* cp)
  72         : model_associator(ma), change_processor(cp) {}
  73   };
  74
  75   virtual ~ProfileSyncComponentsFactory() OVERRIDE {}
  76
  77   // Creates and registers enabled datatypes with the provided
  78   // ProfileSyncService.
  79   virtual void RegisterDataTypes(ProfileSyncService* pss) = 0;
  80
  81   // Instantiates a new DataTypeManager with a SyncBackendHost, a list of data
  82   // type controllers and a DataTypeManagerObserver.  The return pointer is
  83   // owned by the caller.
  84   virtual sync_driver::DataTypeManager* CreateDataTypeManager(
  85       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
  86           debug_info_listener,
  87       const sync_driver::DataTypeController::TypeMap* controllers,
  88       const sync_driver::DataTypeEncryptionHandler* encryption_handler,
  89       browser_sync::SyncBackendHost* backend,
  90       sync_driver::DataTypeManagerObserver* observer,
  91       sync_driver::FailedDataTypesHandler* failed_data_types_handler) = 0;
  92
  93   // Creating this in the factory helps us mock it out in testing.
  94   virtual browser_sync::SyncBackendHost* CreateSyncBackendHost(
  95       const std::string& name,
  96       Profile* profile,
  97       invalidation::InvalidationService* invalidator,
  98       const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
  99       const base::FilePath& sync_folder) = 0;
 100
 101   // Creating this in the factory helps us mock it out in testing.
 102   virtual scoped_ptr<browser_sync::LocalDeviceInfoProvider>
 103       CreateLocalDeviceInfoProvider() = 0;
 104
 105   // Legacy datatypes that need to be converted to the SyncableService API.
 106   virtual SyncComponents CreateBookmarkSyncComponents(
 107       ProfileSyncService* profile_sync_service,
 108       sync_driver::DataTypeErrorHandler* error_handler) = 0;
 109   virtual SyncComponents CreateTypedUrlSyncComponents(
 110       ProfileSyncService* profile_sync_service,
 111       history::HistoryBackend* history_backend,
 112       sync_driver::DataTypeErrorHandler* error_handler) = 0;
 113 };
 114
 115 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_COMPONENTS_FACTORY_H__