Throttle Socket watcher RTT notifications from QUIC

net/nqe/socket_watcher.cc

 // Copyright 2016 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 "net/nqe/socket_watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
+#include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 
 namespace net {
 
 namespace nqe {
 
 namespace internal {
 
 SocketWatcher::SocketWatcher(
     SocketPerformanceWatcherFactory::Protocol protocol,
+    base::TimeDelta min_notification_interval,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     OnUpdatedRTTAvailableCallback updated_rtt_observation_callback)
     : protocol_(protocol),
       task_runner_(std::move(task_runner)),
-      updated_rtt_observation_callback_(updated_rtt_observation_callback) {}
+      updated_rtt_observation_callback_(updated_rtt_observation_callback),
+      rtt_notifications_minimum_interval_(min_notification_interval),
+      tick_clock_(new base::DefaultTickClock()) {}
 
 SocketWatcher::~SocketWatcher() {}
 
 bool SocketWatcher::ShouldNotifyUpdatedRTT() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  return true;
+  // Do not allow incoming notifications if the last notification was recent

[RyanSturm, 2017/02/15 17:42:08]

nit:s/was recent than/was more recent than/

[tbansal1, 2017/02/15 20:37:42]

Done.

+  // than |rtt_notifications_minimum_interval_| ago. This helps in reducing the
+  // overhead of obtaining the RTT values.
+  return tick_clock_->NowTicks() - last_rtt_notification_ >=
+         rtt_notifications_minimum_interval_;
 }
 
 void SocketWatcher::OnUpdatedRTTAvailable(const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  last_rtt_notification_ = tick_clock_->NowTicks();
   task_runner_->PostTask(
       FROM_HERE, base::Bind(updated_rtt_observation_callback_, protocol_, rtt));
 }
 
 void SocketWatcher::OnConnectionChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
+void SocketWatcher::SetTickClockForTesting(
+    std::unique_ptr<base::TickClock> tick_clock) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  tick_clock_ = std::move(tick_clock);
+}
+
 }  // namespace internal
 
 }  // namespace nqe
 
 }  // namespace net