sync/notifier/sync_invalidation_listener.h

   1 // Copyright 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 // A simple wrapper around invalidation::InvalidationClient that
   6 // handles all the startup/shutdown details and hookups.
   7
   8 #ifndef SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
   9 #define SYNC_NOTIFIER_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 "google/cacheinvalidation/include/invalidation-listener.h"
  20 #include "jingle/notifier/listener/push_client_observer.h"
  21 #include "sync/base/sync_export.h"
  22 #include "sync/internal_api/public/util/weak_handle.h"
  23 #include "sync/notifier/ack_tracker.h"
  24 #include "sync/notifier/invalidation_state_tracker.h"
  25 #include "sync/notifier/invalidator_state.h"
  26 #include "sync/notifier/object_id_invalidation_map.h"
  27 #include "sync/notifier/state_writer.h"
  28 #include "sync/notifier/sync_system_resources.h"
  29
  30 namespace base {
  31 class TickClock;
  32 }  // namespace base
  33
  34 namespace buzz {
  35 class XmppTaskParentInterface;
  36 }  // namespace buzz
  37
  38 namespace notifier {
  39 class PushClient;
  40 }  // namespace notifier
  41
  42 namespace syncer {
  43
  44 class RegistrationManager;
  45
  46 // SyncInvalidationListener is not thread-safe and lives on the sync
  47 // thread.
  48 class SYNC_EXPORT_PRIVATE SyncInvalidationListener
  49     : public NON_EXPORTED_BASE(invalidation::InvalidationListener),
  50       public StateWriter,
  51       public NON_EXPORTED_BASE(notifier::PushClientObserver),
  52       public base::NonThreadSafe,
  53       public AckTracker::Delegate {
  54  public:
  55   typedef base::Callback<invalidation::InvalidationClient*(
  56       invalidation::SystemResources*,
  57       int,
  58       const invalidation::string&,
  59       const invalidation::string&,
  60       invalidation::InvalidationListener*)> CreateInvalidationClientCallback;
  61
  62   class SYNC_EXPORT_PRIVATE Delegate {
  63    public:
  64     virtual ~Delegate();
  65
  66     virtual void OnInvalidate(
  67         const ObjectIdInvalidationMap& invalidation_map) = 0;
  68
  69     virtual void OnInvalidatorStateChange(InvalidatorState state) = 0;
  70   };
  71
  72   explicit SyncInvalidationListener(
  73       base::TickClock* tick_clock,
  74       scoped_ptr<notifier::PushClient> push_client);
  75
  76   // Calls Stop().
  77   virtual ~SyncInvalidationListener();
  78
  79   // Does not take ownership of |delegate| or |state_writer|.
  80   // |invalidation_state_tracker| must be initialized.
  81   void Start(
  82       const CreateInvalidationClientCallback&
  83           create_invalidation_client_callback,
  84       const std::string& client_id, const std::string& client_info,
  85       const std::string& invalidation_bootstrap_data,
  86       const InvalidationStateMap& initial_invalidation_state_map,
  87       const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
  88       Delegate* delegate);
  89
  90   void UpdateCredentials(const std::string& email, const std::string& token);
  91
  92   // Update the set of object IDs that we're interested in getting
  93   // notifications for.  May be called at any time.
  94   void UpdateRegisteredIds(const ObjectIdSet& ids);
  95   // Acknowledge that an invalidation for |id| was handled.
  96   void Acknowledge(const invalidation::ObjectId& id,
  97                    const AckHandle& ack_handle);
  98
  99   // invalidation::InvalidationListener implementation.
 100   virtual void Ready(
 101       invalidation::InvalidationClient* client) OVERRIDE;
 102   virtual void Invalidate(
 103       invalidation::InvalidationClient* client,
 104       const invalidation::Invalidation& invalidation,
 105       const invalidation::AckHandle& ack_handle) OVERRIDE;
 106   virtual void InvalidateUnknownVersion(
 107       invalidation::InvalidationClient* client,
 108       const invalidation::ObjectId& object_id,
 109       const invalidation::AckHandle& ack_handle) OVERRIDE;
 110   virtual void InvalidateAll(
 111       invalidation::InvalidationClient* client,
 112       const invalidation::AckHandle& ack_handle) OVERRIDE;
 113   virtual void InformRegistrationStatus(
 114       invalidation::InvalidationClient* client,
 115       const invalidation::ObjectId& object_id,
 116       invalidation::InvalidationListener::RegistrationState reg_state) OVERRIDE;
 117   virtual void InformRegistrationFailure(
 118       invalidation::InvalidationClient* client,
 119       const invalidation::ObjectId& object_id,
 120       bool is_transient,
 121       const std::string& error_message) OVERRIDE;
 122   virtual void ReissueRegistrations(
 123       invalidation::InvalidationClient* client,
 124       const std::string& prefix,
 125       int prefix_length) OVERRIDE;
 126   virtual void InformError(
 127       invalidation::InvalidationClient* client,
 128       const invalidation::ErrorInfo& error_info) OVERRIDE;
 129
 130   // StateWriter implementation.
 131   virtual void WriteState(const std::string& state) OVERRIDE;
 132
 133   // notifier::PushClientObserver implementation.
 134   virtual void OnNotificationsEnabled() OVERRIDE;
 135   virtual void OnNotificationsDisabled(
 136       notifier::NotificationsDisabledReason reason) OVERRIDE;
 137   virtual void OnIncomingNotification(
 138       const notifier::Notification& notification) OVERRIDE;
 139
 140   void DoRegistrationUpdate();
 141
 142   void StopForTest();
 143   InvalidationStateMap GetStateMapForTest() const;
 144   AckTracker* GetAckTrackerForTest();
 145
 146  private:
 147   void Stop();
 148
 149   InvalidatorState GetState() const;
 150
 151   void EmitStateChange();
 152
 153   void PrepareInvalidation(const ObjectIdSet& ids,
 154                            int64 version,
 155                            const std::string& payload,
 156                            invalidation::InvalidationClient* client,
 157                            const invalidation::AckHandle& ack_handle);
 158   void EmitInvalidation(const ObjectIdSet& ids,
 159                         int64 version,
 160                         const std::string& payload,
 161                         invalidation::InvalidationClient* client,
 162                         const invalidation::AckHandle& ack_handle,
 163                         const AckHandleMap& local_ack_handles);
 164
 165   // AckTracker::Delegate implementation.
 166   virtual void OnTimeout(const ObjectIdSet& ids) OVERRIDE;
 167
 168   base::WeakPtrFactory<SyncInvalidationListener> weak_ptr_factory_;
 169   AckTracker ack_tracker_;
 170
 171   // Owned by |sync_system_resources_|.
 172   notifier::PushClient* const push_client_;
 173   SyncSystemResources sync_system_resources_;
 174   InvalidationStateMap invalidation_state_map_;
 175   WeakHandle<InvalidationStateTracker> invalidation_state_tracker_;
 176   Delegate* delegate_;
 177   scoped_ptr<invalidation::InvalidationClient> invalidation_client_;
 178   scoped_ptr<RegistrationManager> registration_manager_;
 179   // Stored to pass to |registration_manager_| on start.
 180   ObjectIdSet registered_ids_;
 181
 182   // The states of the ticl and the push client.
 183   InvalidatorState ticl_state_;
 184   InvalidatorState push_client_state_;
 185
 186   DISALLOW_COPY_AND_ASSIGN(SyncInvalidationListener);
 187 };
 188
 189 }  // namespace syncer
 190
 191 #endif  // SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_