Home | History | Annotate | Download | only in sync 
      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 class WebDataService;
     24 
     25 namespace browser_sync {
     26 class AssociatorInterface;
     27 class ChangeProcessor;
     28 class DataTypeEncryptionHandler;
     29 class DataTypeManager;
     30 class DataTypeManagerObserver;
     31 class FailedDataTypesHandler;
     32 class GenericChangeProcessor;
     33 class SyncBackendHost;
     34 class DataTypeErrorHandler;
     35 }  // namespace browser_sync
     36 
     37 namespace sync_driver {
     38 class SyncPrefs;
     39 }
     40 
     41 namespace syncer {
     42 class DataTypeDebugInfoListener;
     43 class SyncableService;
     44 }
     45 
     46 namespace history {
     47 class HistoryBackend;
     48 }
     49 
     50 // Factory class for all profile sync related classes.
     51 class ProfileSyncComponentsFactory
     52     : public browser_sync::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     browser_sync::AssociatorInterface* model_associator;
     69     browser_sync::ChangeProcessor* change_processor;
     70     SyncComponents(browser_sync::AssociatorInterface* ma,
     71                    browser_sync::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 browser_sync::DataTypeManager* CreateDataTypeManager(
     85       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
     86           debug_info_listener,
     87       const browser_sync::DataTypeController::TypeMap* controllers,
     88       const browser_sync::DataTypeEncryptionHandler* encryption_handler,
     89       browser_sync::SyncBackendHost* backend,
     90       browser_sync::DataTypeManagerObserver* observer,
     91       browser_sync::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   // Legacy datatypes that need to be converted to the SyncableService API.
    102   virtual SyncComponents CreateBookmarkSyncComponents(
    103       ProfileSyncService* profile_sync_service,
    104       browser_sync::DataTypeErrorHandler* error_handler) = 0;
    105   virtual SyncComponents CreateTypedUrlSyncComponents(
    106       ProfileSyncService* profile_sync_service,
    107       history::HistoryBackend* history_backend,
    108       browser_sync::DataTypeErrorHandler* error_handler) = 0;
    109 };
    110 
    111 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_COMPONENTS_FACTORY_H__
    112