Remove WeakHandle from components/invalidation

components/invalidation/invalidation.cc

 // Copyright 2014 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 "components/invalidation/invalidation.h"
 
 #include <cstddef>
 
+#include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/location.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "components/invalidation/ack_handler.h"
 #include "components/invalidation/invalidation_util.h"
 
 namespace syncer {
 
 namespace {
 const char kObjectIdKey[] = "objectId";
@@ skipping 82 matching lines @@
 
 const std::string& Invalidation::payload() const {
   DCHECK(!is_unknown_version_);
   return payload_;
 }
 
 const AckHandle& Invalidation::ack_handle() const {
   return ack_handle_;
 }
 
-void Invalidation::set_ack_handler(syncer::WeakHandle<AckHandler> handler) {
+void Invalidation::SetAckHandler(
+    base::WeakPtr<AckHandler> handler,
+    scoped_refptr<base::SequencedTaskRunner> handler_task_runner) {
   ack_handler_ = handler;
+  ack_handler_task_runner_ = handler_task_runner;
 }
 
 bool Invalidation::SupportsAcknowledgement() const {
-  return ack_handler_.IsInitialized();
+  return !!ack_handler_task_runner_;

[pavely, 2014/08/08 20:08:30]

I think previous code will return false if ack_handler_ gets deleted. The new
code will return true. Does it matter?

[rlarocque, 2014/08/08 21:19:35]

This version is actually more correct.  SupportsAcknowledgement() was meant to
reflect how the object was constructed, not whether or not a shutdown is in
progress.

The documentation explains it a bit more.  Clients are allowed to ignore this
flag and call Acknowledge() or Drop() regardless of its value, so it shouldn't
matter too much what value it returns.

 }
 
 void Invalidation::Acknowledge() const {
   if (SupportsAcknowledgement()) {
-    ack_handler_.Call(FROM_HERE, &AckHandler::Acknowledge, id_, ack_handle_);
+    ack_handler_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&AckHandler::Acknowledge, ack_handler_, id_, ack_handle_));
   }
 }
 
 void Invalidation::Drop() {
   if (SupportsAcknowledgement()) {
-    ack_handler_.Call(FROM_HERE, &AckHandler::Drop, id_, ack_handle_);
+    ack_handler_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&AckHandler::Drop, ack_handler_, id_, ack_handle_));
   }
 }
 
 bool Invalidation::Equals(const Invalidation& other) const {
   return id_ == other.id_ && is_unknown_version_ == other.is_unknown_version_ &&
          version_ == other.version_ && payload_ == other.payload_;
 }
 
 scoped_ptr<base::DictionaryValue> Invalidation::ToValue() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
@@ skipping 22 matching lines @@
                            const std::string& payload,
                            AckHandle ack_handle)
     : id_(id),
       is_unknown_version_(is_unknown_version),
       version_(version),
       payload_(payload),
       ack_handle_(ack_handle) {
 }
 
 }  // namespace syncer