components/invalidation/sync_invalidation_listener.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 // A simple wrapper around invalidation::InvalidationClient that
   6 // handles all the startup/shutdown details and hookups.
   7
   8 #ifndef COMPONENTS_INVALIDATION_SYNC_INVALIDATION_LISTENER_H_
   9 #define COMPONENTS_INVALIDATION_SYNC_INVALIDATION_LISTENER_H_
  10
  11 #include <string>
  12
  13 #include "base/basictypes.h"
  14 #include "base/callback_forward.h"
  15 #include "base/compiler_specific.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/threading/non_thread_safe.h"
  19 #include "components/invalidation/ack_handler.h"
  20 #include "components/invalidation/invalidation_export.h"
  21 #include "components/invalidation/invalidation_state_tracker.h"
  22 #include "components/invalidation/invalidator_state.h"
  23 #include "components/invalidation/state_writer.h"
  24 #include "components/invalidation/sync_system_resources.h"
  25 #include "components/invalidation/unacked_invalidation_set.h"
  26 #include "google/cacheinvalidation/include/invalidation-listener.h"
  27
  28 namespace buzz {
  29 class XmppTaskParentInterface;
  30 }  // namespace buzz
  31
  32 namespace notifier {
  33 class PushClient;
  34 }  // namespace notifier
  35
  36 namespace syncer {
  37
  38 class ObjectIdInvalidationMap;
  39 class RegistrationManager;
  40
  41 // SyncInvalidationListener is not thread-safe and lives on the sync
  42 // thread.
  43 class INVALIDATION_EXPORT_PRIVATE SyncInvalidationListener
  44     : public NON_EXPORTED_BASE(invalidation::InvalidationListener),
  45       public StateWriter,
  46       public SyncNetworkChannel::Observer,
  47       public AckHandler,
  48       public base::NonThreadSafe {
  49  public:
  50   typedef base::Callback<invalidation::InvalidationClient*(
  51       invalidation::SystemResources*,
  52       int,
  53       const invalidation::string&,
  54       const invalidation::string&,
  55       invalidation::InvalidationListener*)> CreateInvalidationClientCallback;
  56
  57   class INVALIDATION_EXPORT_PRIVATE Delegate {
  58    public:
  59     virtual ~Delegate();
  60
  61     virtual void OnInvalidate(
  62         const ObjectIdInvalidationMap& invalidations) = 0;
  63
  64     virtual void OnInvalidatorStateChange(InvalidatorState state) = 0;
  65   };
  66
  67   explicit SyncInvalidationListener(
  68       scoped_ptr<SyncNetworkChannel> network_channel);
  69
  70   // Calls Stop().
  71   virtual ~SyncInvalidationListener();
  72
  73   // Does not take ownership of |delegate| or |state_writer|.
  74   // |invalidation_state_tracker| must be initialized.
  75   void Start(
  76       const CreateInvalidationClientCallback&
  77           create_invalidation_client_callback,
  78       const std::string& client_id,
  79       const std::string& client_info,
  80       const std::string& invalidation_bootstrap_data,
  81       const UnackedInvalidationsMap& initial_object_states,
  82       const base::WeakPtr<InvalidationStateTracker>& invalidation_state_tracker,
  83       const scoped_refptr<base::SequencedTaskRunner>&
  84           invalidation_state_tracker_task_runner,
  85       Delegate* delegate);
  86
  87   void UpdateCredentials(const std::string& email, const std::string& token);
  88
  89   // Update the set of object IDs that we're interested in getting
  90   // notifications for.  May be called at any time.
  91   void UpdateRegisteredIds(const ObjectIdSet& ids);
  92
  93   // invalidation::InvalidationListener implementation.
  94   virtual void Ready(
  95       invalidation::InvalidationClient* client) OVERRIDE;
  96   virtual void Invalidate(
  97       invalidation::InvalidationClient* client,
  98       const invalidation::Invalidation& invalidation,
  99       const invalidation::AckHandle& ack_handle) OVERRIDE;
 100   virtual void InvalidateUnknownVersion(
 101       invalidation::InvalidationClient* client,
 102       const invalidation::ObjectId& object_id,
 103       const invalidation::AckHandle& ack_handle) OVERRIDE;
 104   virtual void InvalidateAll(
 105       invalidation::InvalidationClient* client,
 106       const invalidation::AckHandle& ack_handle) OVERRIDE;
 107   virtual void InformRegistrationStatus(
 108       invalidation::InvalidationClient* client,
 109       const invalidation::ObjectId& object_id,
 110       invalidation::InvalidationListener::RegistrationState reg_state) OVERRIDE;
 111   virtual void InformRegistrationFailure(
 112       invalidation::InvalidationClient* client,
 113       const invalidation::ObjectId& object_id,
 114       bool is_transient,
 115       const std::string& error_message) OVERRIDE;
 116   virtual void ReissueRegistrations(
 117       invalidation::InvalidationClient* client,
 118       const std::string& prefix,
 119       int prefix_length) OVERRIDE;
 120   virtual void InformError(
 121       invalidation::InvalidationClient* client,
 122       const invalidation::ErrorInfo& error_info) OVERRIDE;
 123
 124   // AckHandler implementation.
 125   virtual void Acknowledge(
 126       const invalidation::ObjectId& id,
 127       const syncer::AckHandle& handle) OVERRIDE;
 128   virtual void Drop(
 129       const invalidation::ObjectId& id,
 130       const syncer::AckHandle& handle) OVERRIDE;
 131
 132   // StateWriter implementation.
 133   virtual void WriteState(const std::string& state) OVERRIDE;
 134
 135   // SyncNetworkChannel::Observer implementation.
 136   virtual void OnNetworkChannelStateChanged(
 137       InvalidatorState invalidator_state) OVERRIDE;
 138
 139   void DoRegistrationUpdate();
 140
 141   void RequestDetailedStatus(
 142       base::Callback<void(const base::DictionaryValue&)> callback) const;
 143
 144   void StopForTest();
 145
 146  private:
 147   void Stop();
 148
 149   InvalidatorState GetState() const;
 150
 151   void EmitStateChange();
 152
 153   // Sends invalidations to their appropriate destination.
 154   //
 155   // If there are no observers registered for them, they will be saved for
 156   // later.
 157   //
 158   // If there are observers registered, they will be saved (to make sure we
 159   // don't drop them until they've been acted on) and emitted to the observers.
 160   void DispatchInvalidations(const ObjectIdInvalidationMap& invalidations);
 161
 162   // Saves invalidations.
 163   //
 164   // This call isn't synchronous so we can't guarantee these invalidations will
 165   // be safely on disk by the end of the call, but it should ensure that the
 166   // data makes it to disk eventually.
 167   void SaveInvalidations(const ObjectIdInvalidationMap& to_save);
 168
 169   // Emits previously saved invalidations to their registered observers.
 170   void EmitSavedInvalidations(const ObjectIdInvalidationMap& to_emit);
 171
 172   // Generate a Dictionary with all the debugging information.
 173   scoped_ptr<base::DictionaryValue> CollectDebugData() const;
 174
 175   base::WeakPtr<AckHandler> AsWeakPtr();
 176
 177   scoped_ptr<SyncNetworkChannel> sync_network_channel_;
 178   SyncSystemResources sync_system_resources_;
 179   UnackedInvalidationsMap unacked_invalidations_map_;
 180   base::WeakPtr<InvalidationStateTracker> invalidation_state_tracker_;
 181   scoped_refptr<base::SequencedTaskRunner>
 182       invalidation_state_tracker_task_runner_;
 183   Delegate* delegate_;
 184   scoped_ptr<invalidation::InvalidationClient> invalidation_client_;
 185   scoped_ptr<RegistrationManager> registration_manager_;
 186   // Stored to pass to |registration_manager_| on start.
 187   ObjectIdSet registered_ids_;
 188
 189   // The states of the ticl and the push client.
 190   InvalidatorState ticl_state_;
 191   InvalidatorState push_client_state_;
 192
 193   base::WeakPtrFactory<SyncInvalidationListener> weak_ptr_factory_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(SyncInvalidationListener);
 196 };
 197
 198 }  // namespace syncer
 199
 200 #endif  // COMPONENTS_INVALIDATION_SYNC_INVALIDATION_LISTENER_H_