Implement Invalidator::Acknowledge

sync/notifier/non_blocking_invalidator.cc

 // 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.
 
 #include "sync/notifier/non_blocking_invalidator.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
       public InvalidationHandler {
  public:
   // Called on parent thread.  |delegate_observer| should be
   // initialized.
   explicit Core(
       const WeakHandle<InvalidationHandler>& delegate_observer);
 
   // Helpers called on I/O thread.
   void Initialize(
       const notifier::NotifierOptions& notifier_options,
-      const InvalidationVersionMap& initial_max_invalidation_versions,
+      const InvalidationStateMap& initial_invalidation_state_map,
       const std::string& initial_invalidation_state,
       const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
       const std::string& client_info);
   void Teardown();
   void UpdateRegisteredIds(const ObjectIdSet& ids);
+  void Acknowledge(const invalidation::ObjectId& id,
+                   const AckHandle& ack_handle);
   void SetUniqueId(const std::string& unique_id);
   void SetStateDeprecated(const std::string& state);
   void UpdateCredentials(const std::string& email, const std::string& token);
 
   // InvalidationHandler implementation (all called on I/O thread by
   // InvalidationNotifier).
   virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
   virtual void OnIncomingInvalidation(
       const ObjectIdStateMap& id_state_map,
       IncomingInvalidationSource source) OVERRIDE;
@@ skipping 16 matching lines @@
     const WeakHandle<InvalidationHandler>& delegate_observer)
     : delegate_observer_(delegate_observer) {
   DCHECK(delegate_observer_.IsInitialized());
 }
 
 NonBlockingInvalidator::Core::~Core() {
 }
 
 void NonBlockingInvalidator::Core::Initialize(
     const notifier::NotifierOptions& notifier_options,
-    const InvalidationVersionMap& initial_max_invalidation_versions,
+    const InvalidationStateMap& initial_invalidation_state_map,
     const std::string& initial_invalidation_state,
     const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
     const std::string& client_info) {
   DCHECK(notifier_options.request_context_getter);
   DCHECK_EQ(notifier::NOTIFICATION_SERVER,
             notifier_options.notification_method);
   network_task_runner_ = notifier_options.request_context_getter->
       GetNetworkTaskRunner();
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_.reset(
       new InvalidationNotifier(
           notifier::PushClient::CreateDefaultOnIOThread(notifier_options),
-          initial_max_invalidation_versions,
+          initial_invalidation_state_map,
           initial_invalidation_state,
           invalidation_state_tracker,
           client_info));
   invalidation_notifier_->RegisterHandler(this);
 }
 
 void NonBlockingInvalidator::Core::Teardown() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->UnregisterHandler(this);
   invalidation_notifier_.reset();
   network_task_runner_ = NULL;
 }
 
 void NonBlockingInvalidator::Core::UpdateRegisteredIds(const ObjectIdSet& ids) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->UpdateRegisteredIds(this, ids);
 }
 
+void NonBlockingInvalidator::Core::Acknowledge(const invalidation::ObjectId& id,
+                                               const AckHandle& ack_handle) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  invalidation_notifier_->Acknowledge(id, ack_handle);
+}
+
 void NonBlockingInvalidator::Core::SetUniqueId(const std::string& unique_id) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->SetUniqueId(unique_id);
 }
 
 void NonBlockingInvalidator::Core::SetStateDeprecated(
     const std::string& state) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->SetStateDeprecated(state);
 }
@@ skipping 15 matching lines @@
     const ObjectIdStateMap& id_state_map, IncomingInvalidationSource source) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &InvalidationHandler::OnIncomingInvalidation,
                           id_state_map,
                           source);
 }
 
 NonBlockingInvalidator::NonBlockingInvalidator(
     const notifier::NotifierOptions& notifier_options,
-    const InvalidationVersionMap& initial_max_invalidation_versions,
+    const InvalidationStateMap& initial_invalidation_state_map,
     const std::string& initial_invalidation_state,
     const WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
     const std::string& client_info)
         : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
           core_(
               new Core(MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()))),
           parent_task_runner_(
               base::ThreadTaskRunnerHandle::Get()),
           network_task_runner_(notifier_options.request_context_getter->
               GetNetworkTaskRunner()) {
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &NonBlockingInvalidator::Core::Initialize,
               core_.get(),
               notifier_options,
-              initial_max_invalidation_versions,
+              initial_invalidation_state_map,
               initial_invalidation_state,
               invalidation_state_tracker,
               client_info))) {
     NOTREACHED();
   }
 }
 
 NonBlockingInvalidator::~NonBlockingInvalidator() {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
@@ skipping 20 matching lines @@
               core_.get(),
               registrar_.GetAllRegisteredIds()))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UnregisterHandler(handler);
 }
 

[Pete Williamson, 2012/09/14 18:28:22]

This travels through a lot of levels.  What does a normal call sequence look
like?  I would imagine you start on one thread with a call to acknowledge on one
class that calls a contained object which passes it to another thread where
another contained object gets it, but it's getting confusing from just looking
at the diffs instead of looking at it in the debugger.  It would be nice to know
the actual names of the function in the order that they get executed during a
call.

[dcheng, 2012/09/14 19:08:49]

It would be easier to explain this in person rather than type it out. I'll try
to see if I can come by the office.

+void NonBlockingInvalidator::Acknowledge(const invalidation::ObjectId& id,
+                                         const AckHandle& ack_handle) {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  if (!network_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &NonBlockingInvalidator::Core::Acknowledge,
+              core_.get(),
+              id,
+              ack_handle))) {
+    NOTREACHED();
+  }
+}
+
 InvalidatorState NonBlockingInvalidator::GetInvalidatorState() const {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   return registrar_.GetInvalidatorState();
 }
 
 void NonBlockingInvalidator::SetUniqueId(const std::string& unique_id) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::SetUniqueId,
@@ skipping 37 matching lines @@
 }
 
 void NonBlockingInvalidator::OnIncomingInvalidation(
         const ObjectIdStateMap& id_state_map,
         IncomingInvalidationSource source) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
 }
 
 }  // namespace syncer