Implement Invalidator::Acknowledge

sync/notifier/sync_invalidation_listener.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // A simple wrapper around invalidation::InvalidationClient that
 // handles all the startup/shutdown details and hookups.
 
 #ifndef SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
 #define SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
 
+#include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
+#include "base/time.h"
+#include "base/timer.h"
 #include "google/cacheinvalidation/include/invalidation-listener.h"
 #include "jingle/notifier/listener/push_client_observer.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator_state.h"
 #include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/notifier/state_writer.h"
 #include "sync/notifier/sync_system_resources.h"
 
 namespace buzz {
@@ skipping 39 matching lines @@
   // Calls Stop().
   virtual ~SyncInvalidationListener();
 
   // Does not take ownership of |delegate| or |state_writer|.
   // |invalidation_state_tracker| must be initialized.
   void Start(
       const CreateInvalidationClientCallback&
           create_invalidation_client_callback,
       const std::string& client_id, const std::string& client_info,
       const std::string& invalidation_bootstrap_data,
-      const InvalidationVersionMap& initial_max_invalidation_versions,
+      const InvalidationStateMap& initial_invalidation_state_map,
       const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
       Delegate* delegate);
 
   void UpdateCredentials(const std::string& email, const std::string& token);
 
   // Update the set of object IDs that we're interested in getting
   // notifications for.  May be called at any time.
   void UpdateRegisteredIds(const ObjectIdSet& ids);
+  // TODO(dcheng): Add a comment.

[akalin, 2012/10/19 13:27:16]

!

[dcheng, 2012/10/19 19:38:11]

Done.

+  void Acknowledge(const invalidation::ObjectId& id,
+                   const AckHandle& ack_handle);
 
   // invalidation::InvalidationListener implementation.
   virtual void Ready(
       invalidation::InvalidationClient* client) OVERRIDE;
   virtual void Invalidate(
       invalidation::InvalidationClient* client,
       const invalidation::Invalidation& invalidation,
       const invalidation::AckHandle& ack_handle) OVERRIDE;
   virtual void InvalidateUnknownVersion(
       invalidation::InvalidationClient* client,
@@ skipping 22 matching lines @@
   // StateWriter implementation.
   virtual void WriteState(const std::string& state) OVERRIDE;
 
   // notifier::PushClientObserver implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
   virtual void OnNotificationsDisabled(
       notifier::NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const notifier::Notification& notification) OVERRIDE;
 
-  void StopForTest();
-
   void DoRegistrationUpdate();
 
+  void StopForTest();
+  // Immediately triggers notifications for unacknowledged invalidations
+  // at the beginning of the queue. |next_invalidation_time| is set to the
+  // expiration time of the first entry in the queue, all unacknowledged
+  // invalidations with the same expiration time are immediately triggered,
+  // and we return true.
+  // If there are no unacknowledged invalidations, then we do nothing and
+  // simply return false.
+  bool TriggerNextTimeoutForTest(base::TimeTicks* next_invalidation_time);
+  base::TimeDelta GetCurrentDelayForTest() const {
+    return timer_.GetCurrentDelay();
+  }
+  InvalidationStateMap GetStateMapForTest() const {
+    return invalidation_state_map_;
+  }
+
  private:
+  struct QueueEntry {
+    QueueEntry(const invalidation::ObjectId& id,
+               const std::string& payload,
+               int retry_count)
+        : id(id), payload(payload), retry_count(retry_count) {
+    }
+
+    invalidation::ObjectId id;
+    std::string payload;
+    int retry_count;
+  };
+  typedef std::multimap<base::TimeTicks, QueueEntry> TimerQueue;
+
   void Stop();
 
   InvalidatorState GetState() const;
 
   void EmitStateChange();
 
-  void EmitInvalidation(const ObjectIdInvalidationMap& invalidation_map);
+  void PrepareInvalidation(const ObjectIdSet& ids,

[akalin, 2012/10/19 13:27:16]

I feel we want to decomp out the queue-managing logic to a separate class.  It
would make it easier to test, and also easier to use the existing exp. backoff
code.

Also, you can then pull that out into its own CL that we can iterate faster
over.  What do you think?

[dcheng, 2012/10/19 19:38:11]

I didn't do it originally because there were already a lot of moving pieces and
it seemed to me at the time that it'd result in more complexity. However, I
think this class is now overly complicated and that would be a good idea (I feel
a bit uncertain about pulling it out into a separate CL though).

+                           const std::string& payload,
+                           invalidation::InvalidationClient* client,
+                           const invalidation::AckHandle& ack_handle);
+  void EmitInvalidation(const ObjectIdSet& ids,
+                        const std::string& payload,
+                        invalidation::InvalidationClient* client,
+                        const invalidation::AckHandle& ack_handle,
+                        const AckHandleMap& local_ack_handles);
+  void ResendUnacknowledgedInvalidations();
+  void ResendUnacknowledgedInvalidationsAt(base::TimeTicks now);
+
+  // Various helpers to manage the queue of items that have pending acks.
+  void InsertId(base::TimeTicks expiration_time,
+                const invalidation::ObjectId& id,
+                const std::string& payload,
+                int retry_count);
+  void RemoveId(const invalidation::ObjectId& id);
+  void RemoveIds(const ObjectIdSet& ids);
+  QueueEntry Pop();
+  void UpdateTimer(base::TimeTicks now);
+
+  base::WeakPtrFactory<SyncInvalidationListener> weak_ptr_factory_;
+  base::OneShotTimer<SyncInvalidationListener> timer_;
+  TimerQueue timer_queue_;
 
   // Owned by |sync_system_resources_|.
   notifier::PushClient* const push_client_;
   SyncSystemResources sync_system_resources_;
-  InvalidationVersionMap max_invalidation_versions_;
+  InvalidationStateMap invalidation_state_map_;
   WeakHandle<InvalidationStateTracker> invalidation_state_tracker_;
   Delegate* delegate_;
   scoped_ptr<invalidation::InvalidationClient> invalidation_client_;
   scoped_ptr<RegistrationManager> registration_manager_;
   // Stored to pass to |registration_manager_| on start.
   ObjectIdSet registered_ids_;
 
   // The states of the ticl and the push client.
   InvalidatorState ticl_state_;
   InvalidatorState push_client_state_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncInvalidationListener);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_