Notify NQE of TCP RTT values

net/base/socket_performance_watcher.h

 // Copyright 2015 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 NET_BASE_SOCKET_PERFORMANCE_WATCHER_H_
 #define NET_BASE_SOCKET_PERFORMANCE_WATCHER_H_
 
+#include <stddef.h>
+
+#include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "net/base/net_export.h"
 #include "net/base/socket_performance_watcher_factory.h"
 
 namespace base {
+class SingleThreadTaskRunner;
 class TimeDelta;
 }  // namespace base
 
 namespace net {
 
 // SocketPerformanceWatcher is the base class for recording and aggregating
 // socket statistics.
 class NET_EXPORT_PRIVATE SocketPerformanceWatcher {
  public:
   // |socket_performance_watcher_factory| is the factory that constructed
-  // |this| watcher.
+  // |this| watcher. |socket_performance_watcher_factory| may live on a
+  // different thread, and should be accessed only on the |task_runner|.
   SocketPerformanceWatcher(
       const SocketPerformanceWatcherFactory::Protocol protocol,
-      SocketPerformanceWatcherFactory* socket_performance_watcher_factory);
+      const base::WeakPtr<SocketPerformanceWatcherFactory>&
+          socket_performance_watcher_factory,

[Ryan Sleevi, 2016/03/21 23:25:32]

DESIGN: You should *NEVER* pass a WeakPtr<Foo> to anything but a
base::Callback<>

[tbansal1, 2016/03/23 20:01:33]

Done.

+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
-  virtual ~SocketPerformanceWatcher();
+  ~SocketPerformanceWatcher();
 
   // Called when updated transport layer RTT information is available. This
   // must be the transport layer RTT from this device to the remote transport
   // layer endpoint. This method is called immediately after the observation is
   // made, hence no timestamp.
-  void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) const;
+  void OnUpdatedRTTAvailable(const base::TimeDelta& rtt);
+
+  // Returns |true| if the current SocketPerformanceWatcher is interested
+  // in receiving a new RTT estimate (via OnUpdatedRTTAvailable).
+  // Callers may use this to avoid doing expensive work computing the
+  // RTT when the SocketPerformanceWatcher is not interested in such
+  // updates.
+  bool ShouldNotifyUpdatedRTT() const WARN_UNUSED_RESULT;
+
+  // Resets the internal state of this SocketPerformanceWatcher in preparation
+  // for observing a new socket.
+  // Note: The new socket must share the same protocol as the previously
+  // observed socket.
+  void Reset();
+
+  base::WeakPtr<SocketPerformanceWatcher> GetWeakPtr();
 
  private:
   // Transport layer protocol used by the socket that |this| is watching.
   const SocketPerformanceWatcherFactory::Protocol protocol_;
 
+  // Number of RTT notifications received.
+  size_t rtt_notification_received_count_;
+
   // |socket_performance_watcher_factory_| is the factory that created
-  // |this| watcher.
-  SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
+  // |this| watcher. |socket_performance_watcher_factory_| may live on a
+  // different thread than |this|.
+  const base::WeakPtr<SocketPerformanceWatcherFactory>
+      socket_performance_watcher_factory_;
+
+  base::ThreadChecker thread_checker_;
+
+  // TaskRunner on which |socket_performance_watcher_factory_| should be
+  // accessed.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  base::WeakPtrFactory<SocketPerformanceWatcher> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketPerformanceWatcher);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SOCKET_PERFORMANCE_WATCHER_H_