src/sync/engine/model_type_sync_worker_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 SYNC_ENGINE_MODEL_TYPE_SYNC_WORKER_IMPL_H_
   6 #define SYNC_ENGINE_MODEL_TYPE_SYNC_WORKER_IMPL_H_
   7
   8 #include "base/memory/weak_ptr.h"
   9 #include "base/stl_util.h"
  10 #include "base/threading/non_thread_safe.h"
  11 #include "sync/base/sync_export.h"
  12 #include "sync/engine/commit_contributor.h"
  13 #include "sync/engine/model_type_sync_worker.h"
  14 #include "sync/engine/nudge_handler.h"
  15 #include "sync/engine/update_handler.h"
  16 #include "sync/internal_api/public/base/model_type.h"
  17 #include "sync/internal_api/public/non_blocking_sync_common.h"
  18 #include "sync/internal_api/public/sync_encryption_handler.h"
  19 #include "sync/protocol/sync.pb.h"
  20 #include "sync/util/cryptographer.h"
  21
  22 namespace base {
  23 class SingleThreadTaskRunner;
  24 }
  25
  26 namespace syncer {
  27
  28 class ModelTypeSyncProxy;
  29 class EntityTracker;
  30
  31 // A smart cache for sync types that use message passing (rather than
  32 // transactions and the syncable::Directory) to communicate with the sync
  33 // thread.
  34 //
  35 // When the non-blocking sync type wants to talk with the sync server, it will
  36 // send a message from its thread to this object on the sync thread.  This
  37 // object ensures the appropriate sync server communication gets scheduled and
  38 // executed.  The response, if any, will be returned to the non-blocking sync
  39 // type's thread eventually.
  40 //
  41 // This object also has a role to play in communications in the opposite
  42 // direction.  Sometimes the sync thread will receive changes from the sync
  43 // server and deliver them here.  This object will post this information back to
  44 // the appropriate component on the model type's thread.
  45 //
  46 // This object does more than just pass along messages.  It understands the sync
  47 // protocol, and it can make decisions when it sees conflicting messages.  For
  48 // example, if the sync server sends down an update for a sync entity that is
  49 // currently pending for commit, this object will detect this condition and
  50 // cancel the pending commit.
  51 class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
  52                                             public CommitContributor,
  53                                             public ModelTypeSyncWorker,
  54                                             public base::NonThreadSafe {
  55  public:
  56   ModelTypeSyncWorkerImpl(ModelType type,
  57                           const DataTypeState& initial_state,
  58                           const UpdateResponseDataList& saved_pending_updates,
  59                           scoped_ptr<Cryptographer> cryptographer,
  60                           NudgeHandler* nudge_handler,
  61                           scoped_ptr<ModelTypeSyncProxy> type_sync_proxy);
  62   virtual ~ModelTypeSyncWorkerImpl();
  63
  64   ModelType GetModelType() const;
  65
  66   bool IsEncryptionRequired() const;
  67   void UpdateCryptographer(scoped_ptr<Cryptographer> cryptographer);
  68
  69   // UpdateHandler implementation.
  70   virtual void GetDownloadProgress(
  71       sync_pb::DataTypeProgressMarker* progress_marker) const OVERRIDE;
  72   virtual void GetDataTypeContext(
  73       sync_pb::DataTypeContext* context) const OVERRIDE;
  74   virtual SyncerError ProcessGetUpdatesResponse(
  75       const sync_pb::DataTypeProgressMarker& progress_marker,
  76       const sync_pb::DataTypeContext& mutated_context,
  77       const SyncEntityList& applicable_updates,
  78       sessions::StatusController* status) OVERRIDE;
  79   virtual void ApplyUpdates(sessions::StatusController* status) OVERRIDE;
  80   virtual void PassiveApplyUpdates(sessions::StatusController* status) OVERRIDE;
  81
  82   // ModelTypeSyncWorker implementation.
  83   virtual void EnqueueForCommit(
  84       const CommitRequestDataList& request_list) OVERRIDE;
  85
  86   // CommitContributor implementation.
  87   virtual scoped_ptr<CommitContribution> GetContribution(
  88       size_t max_entries) OVERRIDE;
  89
  90   // Callback for when our contribution gets a response.
  91   void OnCommitResponse(const CommitResponseDataList& response_list);
  92
  93   base::WeakPtr<ModelTypeSyncWorkerImpl> AsWeakPtr();
  94
  95  private:
  96   typedef std::map<std::string, EntityTracker*> EntityMap;
  97   typedef std::map<std::string, UpdateResponseData*> UpdateMap;
  98
  99   // Stores a single commit request in this object's internal state.
 100   void StorePendingCommit(const CommitRequestData& request);
 101
 102   // Returns true if this type has successfully fetched all available updates
 103   // from the server at least once.  Our state may or may not be stale, but at
 104   // least we know that it was valid at some point in the past.
 105   bool IsTypeInitialized() const;
 106
 107   // Returns true if this type is prepared to commit items.  Currently, this
 108   // depends on having downloaded the initial data and having the encryption
 109   // settings in a good state.
 110   bool CanCommitItems() const;
 111
 112   // Initializes the parts of a commit entity that are the responsibility of
 113   // this class, and not the EntityTracker.  Some fields, like the
 114   // client-assigned ID, can only be set by an entity with knowledge of the
 115   // entire data type's state.
 116   void HelpInitializeCommitEntity(sync_pb::SyncEntity* commit_entity);
 117
 118   // Attempts to decrypt pending updates stored in the EntityMap.  If
 119   // successful, will remove the update from the its EntityTracker and forward
 120   // it to the proxy thread for application.  Will forward any new encryption
 121   // keys to the proxy to trigger re-encryption if necessary.
 122   void OnCryptographerUpdated();
 123
 124   // Attempts to decrypt the given specifics and return them in the |out|
 125   // parameter.  Assumes cryptographer->CanDecrypt(specifics) returned true.
 126   //
 127   // Returns false if the decryption failed.  There are no guarantees about the
 128   // contents of |out| when that happens.
 129   //
 130   // In theory, this should never fail.  Only corrupt or invalid entries could
 131   // cause this to fail, and no clients are known to create such entries.  The
 132   // failure case is an attempt to be defensive against bad input.
 133   static bool DecryptSpecifics(Cryptographer* cryptographer,
 134                                const sync_pb::EntitySpecifics& in,
 135                                sync_pb::EntitySpecifics* out);
 136
 137   ModelType type_;
 138
 139   // State that applies to the entire model type.
 140   DataTypeState data_type_state_;
 141
 142   // Pointer to the ModelTypeSyncProxy associated with this worker.
 143   // This is NULL when no proxy is connected..
 144   scoped_ptr<ModelTypeSyncProxy> type_sync_proxy_;
 145
 146   // A private copy of the most recent cryptographer known to sync.
 147   // Initialized at construction time and updated with UpdateCryptographer().
 148   // NULL if encryption is not enabled for this type.
 149   scoped_ptr<Cryptographer> cryptographer_;
 150
 151   // Interface used to access and send nudges to the sync scheduler.  Not owned.
 152   NudgeHandler* nudge_handler_;
 153
 154   // A map of per-entity information known to this object.
 155   //
 156   // When commits are pending, their information is stored here.  This
 157   // information is dropped from memory when the commit succeeds or gets
 158   // cancelled.
 159   //
 160   // This also stores some information related to received server state in
 161   // order to implement reflection blocking and conflict detection.  This
 162   // information is kept in memory indefinitely.  With a bit more coordination
 163   // with the model thread, we could optimize this to reduce memory usage in
 164   // the steady state.
 165   EntityMap entities_;
 166   STLValueDeleter<EntityMap> entities_deleter_;
 167
 168   base::WeakPtrFactory<ModelTypeSyncWorkerImpl> weak_ptr_factory_;
 169 };
 170
 171 }  // namespace syncer
 172
 173 #endif  // SYNC_ENGINE_MODEL_TYPE_SYNC_WORKER_IMPL_H_