Notify NQE of TCP RTT values

net/base/socket_performance_watcher_factory.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_FACTORY_H_
 #define NET_BASE_SOCKET_PERFORMANCE_WATCHER_FACTORY_H_
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/net_export.h"
@@ skipping 24 matching lines @@
       const Protocol protocol) = 0;
 
   // Called when updated transport layer RTT information is available from one
   // of the watchers created by |this|. |protocol| is the protocol that was used
   // by the watcher. |rtt| must be the transport layer RTT from this device to
   // the remote transport layer endpoint. These methods are called immediately
   // after the observation is made, hence no timestamp.
   virtual void OnUpdatedRTTAvailable(const Protocol protocol,
                                      const base::TimeDelta& rtt) = 0;
 
+  // Called when one of the watchers created by |this| is being reused for
+  // another transport layer connection.
+  virtual void WatcherReset() = 0;

[Ryan Sleevi, 2016/02/25 22:48:46]

1) Who guarantees that it's called by this? Same with line 37? That seems to be
the responsibility of the SocketPerformanceWatcher, which may be a subclass

2) If it's called, have it On*; if it's directing an action ("You go Reset
this"), call it Reset

3) In order to provide for the invariants you document on line 37 and 45 (e.g.
that these methods are *only* called then), they should be protected methods for
subclasses to override. If your goal is to allow SocketPerformanceWatcher to
call back in to the Factory, then you're fundamentally talking about a design
circular loop (SPWF -> SocketPerformanceWatcher, SPW is required to call
SPWF->On*). You need to break that loop through delegation - SPW defines a
delegate that receives notifications of interesting events, SPWF provides (but
*does not* directly implement) that delegate, and the SPWF delegate then
triggers the SPWF's (protected) methods.

Let me know if you're not clear on these concerns and I can explain them more,
since that'll be easier before you start coding.

[tbansal1, 2016/02/26 23:43:34]

Done.
This is a good suggestion. I filed crbug.com/590265 to track this. I would
prefer to fix this in a separate CL, since this CL has already become too
unwieldy.

+
  protected:
   SocketPerformanceWatcherFactory() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SocketPerformanceWatcherFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SOCKET_PERFORMANCE_WATCHER_FACTORY_H_