components/sync_driver/device_info_sync_service.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_DEVICE_INFO_SYNC_SERVICE_H_
   6 #define COMPONENTS_SYNC_DRIVER_DEVICE_INFO_SYNC_SERVICE_H_
   7
   8 #include "base/observer_list.h"
   9 #include "components/sync_driver/device_info_tracker.h"
  10 #include "sync/api/sync_change_processor.h"
  11 #include "sync/api/sync_data.h"
  12 #include "sync/api/sync_error_factory.h"
  13 #include "sync/api/syncable_service.h"
  14
  15 namespace sync_driver {
  16
  17 class LocalDeviceInfoProvider;
  18
  19 // SyncableService implementation for DEVICE_INFO model type.
  20 class DeviceInfoSyncService : public syncer::SyncableService,
  21                               public DeviceInfoTracker {
  22  public:
  23   explicit DeviceInfoSyncService(
  24       LocalDeviceInfoProvider* local_device_info_provider);
  25   ~DeviceInfoSyncService() override;
  26
  27   // syncer::SyncableService implementation.
  28   syncer::SyncMergeResult MergeDataAndStartSyncing(
  29       syncer::ModelType type,
  30       const syncer::SyncDataList& initial_sync_data,
  31       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
  32       scoped_ptr<syncer::SyncErrorFactory> error_handler) override;
  33   void StopSyncing(syncer::ModelType type) override;
  34   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
  35   syncer::SyncError ProcessSyncChanges(
  36       const tracked_objects::Location& from_here,
  37       const syncer::SyncChangeList& change_list) override;
  38
  39   // DeviceInfoTracker implementation.
  40   bool IsSyncing() const override;
  41   scoped_ptr<DeviceInfo> GetDeviceInfo(
  42       const std::string& client_id) const override;
  43   ScopedVector<DeviceInfo> GetAllDeviceInfo() const override;
  44   void AddObserver(Observer* observer) override;
  45   void RemoveObserver(Observer* observer) override;
  46
  47   // Called to update local device backup time.
  48   void UpdateLocalDeviceBackupTime(base::Time backup_time);
  49   // Gets the most recently set local device backup time.
  50   base::Time GetLocalDeviceBackupTime() const;
  51
  52  private:
  53   // Create SyncData from local DeviceInfo and |local_device_backup_time_|.
  54   syncer::SyncData CreateLocalData(const DeviceInfo* info);
  55   // Create SyncData from EntitySpecifics.
  56   static syncer::SyncData CreateLocalData(
  57       const sync_pb::EntitySpecifics& entity);
  58
  59   // Allocate new DeviceInfo from SyncData.
  60   static DeviceInfo* CreateDeviceInfo(const syncer::SyncData sync_data);
  61   // Store SyncData in the cache.
  62   void StoreSyncData(const std::string& client_id,
  63                      const syncer::SyncData& sync_data);
  64   // Delete SyncData from the cache.
  65   void DeleteSyncData(const std::string& client_id);
  66   // Notify all registered observers.
  67   void NotifyObservers();
  68
  69   // Updates backup time in place in |sync_data| if it is different than
  70   // the one stored in |local_device_backup_time_|.
  71   // Returns true if backup time was updated.
  72   bool UpdateBackupTime(syncer::SyncData* sync_data);
  73
  74   // |local_device_backup_time_| accessors.
  75   int64 local_device_backup_time() const { return local_device_backup_time_; }
  76   bool has_local_device_backup_time() const {
  77     return local_device_backup_time_ >= 0;
  78   }
  79   void set_local_device_backup_time(int64 value) {
  80     local_device_backup_time_ = value;
  81   }
  82   void clear_local_device_backup_time() { local_device_backup_time_ = -1; }
  83
  84   // Local device last set backup time (in proto format).
  85   // -1 if the value hasn't been specified
  86   int64 local_device_backup_time_;
  87
  88   // |local_device_info_provider_| isn't owned.
  89   const LocalDeviceInfoProvider* const local_device_info_provider_;
  90
  91   // Receives ownership of |sync_processor_| and |error_handler_| in
  92   // MergeDataAndStartSyncing() and destroy them in StopSyncing().
  93   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
  94   scoped_ptr<syncer::SyncErrorFactory> error_handler_;
  95
  96   // Cache of all syncable and local data.
  97   typedef std::map<std::string, syncer::SyncData> SyncDataMap;
  98   SyncDataMap all_data_;
  99
 100   // Registered observers, not owned.
 101   ObserverList<Observer, true> observers_;
 102
 103   DISALLOW_COPY_AND_ASSIGN(DeviceInfoSyncService);
 104 };
 105
 106 }  // namespace sync_driver
 107
 108 #endif  // COMPONENTS_SYNC_DRIVER_DEVICE_INFO_SYNC_SERVICE_H_