src/sync/engine/non_blocking_type_processor_core.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_NON_BLOCKING_TYPE_PROCESSOR_CORE_H_
   6 #define SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_CORE_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/non_blocking_sync_common.h"
  14 #include "sync/engine/update_handler.h"
  15 #include "sync/internal_api/public/base/model_type.h"
  16 #include "sync/protocol/sync.pb.h"
  17
  18 namespace base {
  19 class SingleThreadTaskRunner;
  20 }
  21
  22 namespace syncer {
  23
  24 class NonBlockingTypeProcessorInterface;
  25 class SyncThreadSyncEntity;
  26
  27 // A smart cache for sync types that use message passing (rather than
  28 // transactions and the syncable::Directory) to communicate with the sync
  29 // thread.
  30 //
  31 // When the non-blocking sync type wants to talk with the sync server, it will
  32 // send a message from its thread to this object on the sync thread.  This
  33 // object ensures the appropriate sync server communication gets scheduled and
  34 // executed.  The response, if any, will be returned to the non-blocking sync
  35 // type's thread eventually.
  36 //
  37 // This object also has a role to play in communications in the opposite
  38 // direction.  Sometimes the sync thread will receive changes from the sync
  39 // server and deliver them here.  This object will post this information back to
  40 // the appropriate component on the model type's thread.
  41 //
  42 // This object does more than just pass along messages.  It understands the sync
  43 // protocol, and it can make decisions when it sees conflicting messages.  For
  44 // example, if the sync server sends down an update for a sync entity that is
  45 // currently pending for commit, this object will detect this condition and
  46 // cancel the pending commit.
  47 class SYNC_EXPORT NonBlockingTypeProcessorCore
  48     : public UpdateHandler,
  49       public CommitContributor,
  50       public base::NonThreadSafe {
  51  public:
  52   NonBlockingTypeProcessorCore(
  53       ModelType type,
  54       const DataTypeState& initial_state,
  55       scoped_ptr<NonBlockingTypeProcessorInterface> processor_interface);
  56   virtual ~NonBlockingTypeProcessorCore();
  57
  58   ModelType GetModelType() const;
  59
  60   // UpdateHandler implementation.
  61   virtual void GetDownloadProgress(
  62       sync_pb::DataTypeProgressMarker* progress_marker) const OVERRIDE;
  63   virtual void GetDataTypeContext(sync_pb::DataTypeContext* context) const
  64       OVERRIDE;
  65   virtual SyncerError ProcessGetUpdatesResponse(
  66       const sync_pb::DataTypeProgressMarker& progress_marker,
  67       const sync_pb::DataTypeContext& mutated_context,
  68       const SyncEntityList& applicable_updates,
  69       sessions::StatusController* status) OVERRIDE;
  70   virtual void ApplyUpdates(sessions::StatusController* status) OVERRIDE;
  71   virtual void PassiveApplyUpdates(sessions::StatusController* status) OVERRIDE;
  72
  73   // Entry point for NonBlockingTypeProcessor to send commit requests.
  74   void EnqueueForCommit(const CommitRequestDataList& request_list);
  75
  76   // CommitContributor implementation.
  77   virtual scoped_ptr<CommitContribution> GetContribution(
  78       size_t max_entries) OVERRIDE;
  79
  80   // Callback for when our contribution gets a response.
  81   void OnCommitResponse(const CommitResponseDataList& response_list);
  82
  83   base::WeakPtr<NonBlockingTypeProcessorCore> AsWeakPtr();
  84
  85  private:
  86   typedef std::map<std::string, SyncThreadSyncEntity*> EntityMap;
  87
  88   // Stores a single commit request in this object's internal state.
  89   void StorePendingCommit(const CommitRequestData& request);
  90
  91   // Returns true if all data type state required for commits is available.  In
  92   // practice, this means that it returns true from the time this object first
  93   // receives notice of a successful update fetch from the server.
  94   bool CanCommitItems() const;
  95
  96   // Initializes the parts of a commit entity that are the responsibility of
  97   // this class, and not the SyncThreadSyncEntity.  Some fields, like the
  98   // client-assigned ID, can only be set by an entity with knowledge of the
  99   // entire data type's state.
 100   void HelpInitializeCommitEntity(sync_pb::SyncEntity* commit_entity);
 101
 102   ModelType type_;
 103
 104   // State that applies to the entire model type.
 105   DataTypeState data_type_state_;
 106
 107   // Abstraction around the NonBlockingTypeProcessor so this class
 108   // doesn't need to know about its specific implementation or
 109   // which thread it's on.  This makes it easier to write tests.
 110   scoped_ptr<NonBlockingTypeProcessorInterface> processor_interface_;
 111
 112   // A map of per-entity information known to this object.
 113   //
 114   // When commits are pending, their information is stored here.  This
 115   // information is dropped from memory when the commit succeeds or gets
 116   // cancelled.
 117   //
 118   // This also stores some information related to received server state in
 119   // order to implement reflection blocking and conflict detection.  This
 120   // information is kept in memory indefinitely.  With a bit more coordination
 121   // with the model thread, we could optimize this to reduce memory usage in
 122   // the steady state.
 123   EntityMap entities_;
 124   STLValueDeleter<EntityMap> entities_deleter_;
 125
 126   base::WeakPtrFactory<NonBlockingTypeProcessorCore> weak_ptr_factory_;
 127 };
 128
 129 }  // namespace syncer
 130
 131 #endif  // SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_CORE_H_