Notfiy NQE of QUIC RTT

net/quic/quic_connection_logger.cc

 // Copyright (c) 2013 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/quic/quic_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/net_util.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/x509_certificate.h"
 #include "net/log/net_log.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_address_mismatch.h"
 #include "net/quic/quic_socket_address_coder.h"
+#include "net/quic/quic_time.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // We have ranges-of-buckets in the cumulative histogram (covering 21 packet
 // sequences) of length 2, 3, 4, ... 22.
@@ skipping 244 matching lines @@
 AddressFamily GetRealAddressFamily(const IPAddressNumber& address) {
   return IsIPv4Mapped(address) ? ADDRESS_FAMILY_IPV4 :
       GetAddressFamily(address);
 }
 
 }  // namespace
 
 QuicConnectionLogger::QuicConnectionLogger(
     QuicSpdySession* session,
     const char* const connection_description,
+    scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     const BoundNetLog& net_log)
     : net_log_(net_log),
       session_(session),
       last_received_packet_number_(0),
       last_received_packet_size_(0),
       previous_received_packet_size_(0),
       largest_received_packet_number_(0),
       largest_received_missing_packet_number_(0),
       num_out_of_order_received_packets_(0),
       num_out_of_order_large_received_packets_(0),
       num_packets_received_(0),
       num_truncated_acks_sent_(0),
       num_truncated_acks_received_(0),
       num_frames_received_(0),
       num_duplicate_frames_received_(0),
       num_incorrect_connection_ids_(0),
       num_undecryptable_packets_(0),
       num_duplicate_packets_(0),
       num_blocked_frames_received_(0),
       num_blocked_frames_sent_(0),
-      connection_description_(connection_description) {}
+      connection_description_(connection_description),
+      socket_performance_watcher_(socket_performance_watcher.Pass()) {}
 
 QuicConnectionLogger::~QuicConnectionLogger() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderPacketsReceived",
                        num_out_of_order_received_packets_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderLargePacketsReceived",
                        num_out_of_order_large_received_packets_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.TruncatedAcksSent",
                        num_truncated_acks_sent_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.TruncatedAcksReceived",
                        num_truncated_acks_received_);
@@ skipping 459 matching lines @@
   }
 }
 
 float QuicConnectionLogger::ReceivedPacketLossRate() const {
   if (largest_received_packet_number_ <= num_packets_received_)
     return 0.0f;
   float num_received = largest_received_packet_number_ - num_packets_received_;
   return num_received / largest_received_packet_number_;
 }
 
+void QuicConnectionLogger::OnRttChanged(QuicTime::Delta rtt) const {
+  // Notify socket performance watcher of the updated RTT value.
+  if (!socket_performance_watcher_)
+    return;
+
+  long microseconds = rtt.ToMicroseconds();

[Ryan Sleevi, 2015/09/18 17:36:45]

BUG: This should be int64

[tbansal1, 2015/09/18 17:59:59]

Done. Thanks for catching that. This is what I get for working on Java (upstream
code) and C++ at the same time.

+  if (microseconds != 0) {
+    socket_performance_watcher_->OnUpdatedRTTAvailable(
+        base::TimeDelta::FromMicroseconds(rtt.ToMicroseconds()));
+  }
+}
+
 void QuicConnectionLogger::RecordAggregatePacketLossRate() const {
   // For short connections under 22 packets in length, we'll rely on the
   // Net.QuicSession.21CumulativePacketsReceived_* histogram to indicate packet
   // loss rates.  This way we avoid tremendously anomalous contributions to our
   // histogram.  (e.g., if we only got 5 packets, but lost 1, we'd otherwise
   // record a 20% loss in this histogram!). We may still get some strange data
   // (1 loss in 22 is still high :-/).
   if (largest_received_packet_number_ <= 21)
     return;
 
@@ skipping 70 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net