Expose packet loss counts from QUIC to NetworkQualityEstimator

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 <utility>
 
@@ skipping 482 matching lines @@
 }
 
 void QuicConnectionLogger::OnProtocolVersionMismatch(
     QuicVersion received_version) {
   // TODO(rtenneti): Add logging.
 }
 
 void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) {
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_AUTHENTICATED);
   ++num_packets_received_;
+
+  const QuicPacketCount previous_largest_received_packet_number =
+      largest_received_packet_number_;
   if (largest_received_packet_number_ < header.packet_number) {
     QuicPacketNumber delta =
         header.packet_number - largest_received_packet_number_;
     if (delta > 1) {
       // There is a gap between the largest packet previously received and
       // the current packet.  This indicates either loss, or out-of-order
       // delivery.
       UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapReceived",
                            static_cast<base::HistogramBase::Sample>(delta - 1));
     }
     largest_received_packet_number_ = header.packet_number;
   }
   if (header.packet_number < received_packets_.size()) {
     received_packets_[static_cast<size_t>(header.packet_number)] = true;
   }
   if (header.packet_number < last_received_packet_number_) {
     ++num_out_of_order_received_packets_;
     if (previous_received_packet_size_ < last_received_packet_size_)
       ++num_out_of_order_large_received_packets_;
     UMA_HISTOGRAM_COUNTS(
         "Net.QuicSession.OutOfOrderGapReceived",
         static_cast<base::HistogramBase::Sample>(last_received_packet_number_ -
                                                  header.packet_number));
   }
   last_received_packet_number_ = header.packet_number;
+  ReportPacketCounts(previous_largest_received_packet_number);
+}
+
+void QuicConnectionLogger::ReportPacketCounts(
+    QuicPacketCount previous_largest_received_packet_number) const {
+  DCHECK_GE(largest_received_packet_number_,
+            previous_largest_received_packet_number);
+  if (!socket_performance_watcher_)
+    return;
+
+  size_t packets_missing = 0;
+  size_t packets_received_in_order = 0;
+  size_t packets_received_out_of_order = 0;
+
+  const size_t diff =
+      largest_received_packet_number_ - previous_largest_received_packet_number;
+
+  if (diff == 0) {
+    // The received packet number has a lower sequence number than the expected
+    // sequence number.
+    packets_received_out_of_order = 1;
+  } else if (diff == 1) {
+    // The received packet number has the same sequence number as the expected
+    // sequence number.
+    packets_received_in_order = 1;
+  } else {
+    // The received packet number has higher sequence number as the expected
+    // sequence number. Report all packets with intermediate sequence numbers
+    // as lost.

[Ryan Hamilton, 2016/03/07 20:02:10]

"Lost" is probably not what you mean to say. How about "currently missing, but
they may be received later and will be counted as out of order"

[tbansal1, 2016/03/08 02:59:58]

Done.

+    // TODO(tbansal): Do not report if |diff| is more than a threshold to avoid
+    // cases where the QUIC transmitter skips certain packet sequence numbers.
+    packets_missing = diff - 1;
+    packets_received_in_order = 1;
+  }
+  socket_performance_watcher_->OnUpdatedPacketCountAvailable(
+      packets_missing, packets_received_in_order,
+      packets_received_out_of_order);
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicAckFrameCallback, &frame));
@@ skipping 227 matching lines @@
     bit_mask_of_packets >>= 1;
     DCHECK_LT(range_start + bits_so_far, kBoundingSampleInCumulativeHistogram);
     histogram->Add(range_start + bits_so_far);
     range_start += i + 1;
   }
 }
 
 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_;
+  float num_lost = largest_received_packet_number_ - num_packets_received_;
+  return num_lost / 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;
 
   int64_t microseconds = rtt.ToMicroseconds();
   if (microseconds != 0) {
     socket_performance_watcher_->OnUpdatedRTTAvailable(
@@ skipping 84 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