Remove WeakHandle from components/invalidation

components/invalidation/invalidation.h

 // 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.
 
 #ifndef COMPONENTS_INVALIDATION_INVALIDATION_H_
 #define COMPONENTS_INVALIDATION_INVALIDATION_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner.h"
 #include "base/values.h"
 #include "components/invalidation/ack_handle.h"
 #include "components/invalidation/invalidation_export.h"
 #include "google/cacheinvalidation/include/types.h"
-#include "sync/internal_api/public/util/weak_handle.h"
 
 namespace syncer {
 
 class DroppedInvalidationTracker;
 class AckHandler;
 
 // Represents a local invalidation, and is roughly analogous to
 // invalidation::Invalidation.  Unlike invalidation::Invalidation, this class
 // supports "local" ack-tracking and simple serialization to pref values.
 class INVALIDATION_EXPORT Invalidation {
@@ skipping 23 matching lines @@
 
   const AckHandle& ack_handle() const;
 
   // Sets the AckHandler to be used to track this Invalidation.
   //
   // This should be set by the class that generates the invalidation.  Clients
   // of the Invalidations API should not need to call this.
   //
   // Note that some sources of invalidations do not support ack tracking, and do
   // not set the ack_handler.  This will be hidden from users of this class.
-  void set_ack_handler(syncer::WeakHandle<AckHandler> ack_handler);
+  void SetAckHandler(
+      base::WeakPtr<AckHandler> handler,
+      scoped_refptr<base::SequencedTaskRunner> handler_task_runner);

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

I've seen usage of const scoped_refptr<...>& in the code which saves you one
pair of AddRef/Release. Do you know if there is any guideline about it?

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

Some support it as an efficiency improvement.  Personally, I think the
improvements are not really measureable, so I'm indifferent.  In this CL, I've
tried to maintain the status quo.

As far as I know, there's no rule about this set out in the style guidelines.  I
guess we should just aim for consistency.  A quick 'grep' tells me that we're
pretty far from that goal.  :(

 
   // Returns whether or not this instance supports ack tracking.  This will
   // depend on whether or not the source of invaliadations supports
   // invalidations.
   //
   // Clients can safely ignore this flag.  They can assume that all
   // invalidations support ack tracking.  If they're wrong, then invalidations
   // will be less reliable, but their behavior will be no less correct.
   bool SupportsAcknowledgement() const;
 
@@ skipping 35 matching lines @@
   // The version number of this invalidation.  Should not be accessed if this is
   // an unkown version invalidation.
   int64 version_;
 
   // The payaload associated with this invalidation.  Should not be accessed if
   // this is an unknown version invalidation.
   std::string payload_;
 
   // A locally generated unique ID used to manage local acknowledgements.
   AckHandle ack_handle_;
-  syncer::WeakHandle<AckHandler> ack_handler_;
+
+  // The acknowledgement tracking handler and its thread.
+  base::WeakPtr<AckHandler> ack_handler_;
+  scoped_refptr<base::SequencedTaskRunner> ack_handler_task_runner_;
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_INVALIDATION_INVALIDATION_H_