Gather histogram for received packets indicating losses.

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.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/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"
@@ skipping 31 matching lines @@
   if (result.status != WRITE_STATUS_OK) {
     dict->SetInteger("net_error", result.error_code);
   }
   return dict;
 }
 
 base::Value* NetLogQuicPacketRetransmittedCallback(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number,
     NetLog::LogLevel /* log_level */) {
- base::DictionaryValue* dict = new base::DictionaryValue();
- dict->SetString("old_packet_sequence_number",
-                 base::Uint64ToString(old_sequence_number));
- dict->SetString("new_packet_sequence_number",
-                 base::Uint64ToString(new_sequence_number));
- return dict;
+  base::DictionaryValue* dict = new base::DictionaryValue();
+  dict->SetString("old_packet_sequence_number",
+                  base::Uint64ToString(old_sequence_number));
+  dict->SetString("new_packet_sequence_number",
+                  base::Uint64ToString(new_sequence_number));
+  return dict;
 }
 
 base::Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header,
                                             NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("guid",
                   base::Uint64ToString(header->public_header.guid));
   dict->SetInteger("reset_flag", header->public_header.reset_flag);
   dict->SetInteger("version_flag", header->public_header.version_flag);
   dict->SetString("packet_sequence_number",
@@ skipping 43 matching lines @@
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   switch (frame->type) {
     case kInterArrival: {
       dict->SetString("type", "InterArrival");
       base::ListValue* received = new base::ListValue();
       dict->Set("received_packets", received);
       for (TimeMap::const_iterator it =
                frame->inter_arrival.received_packet_times.begin();
            it != frame->inter_arrival.received_packet_times.end(); ++it) {
-        std::string value = base::Uint64ToString(it->first) + "@" +
+        string value = base::Uint64ToString(it->first) + "@" +
             base::Uint64ToString(it->second.ToDebuggingValue());
         received->AppendString(value);
       }
       break;
     }
     case kFixRate:
       dict->SetString("type", "FixRate");
       dict->SetInteger("bitrate_in_bytes_per_second",
                        frame->fix_rate.bitrate.ToBytesPerSecond());
       break;
@@ skipping 76 matching lines @@
 
 }  // namespace
 
 QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
     : net_log_(net_log),
       last_received_packet_sequence_number_(0),
       largest_received_packet_sequence_number_(0),
       largest_received_missing_packet_sequence_number_(0),
       out_of_order_recieved_packet_count_(0),
       num_truncated_acks_sent_(0),
-      num_truncated_acks_received_(0) {
+      num_truncated_acks_received_(0),
+      connection_type_(NetworkChangeNotifier::GetConnectionType()) {
 }
 
 QuicConnectionLogger::~QuicConnectionLogger() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderPacketsReceived",
                        out_of_order_recieved_packet_count_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.TruncatedAcksSent",
                        num_truncated_acks_sent_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.TruncatedAcksReceived",
                        num_truncated_acks_received_);
+
+  RecordAckNackHistograms();
 }
 
 void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) {
   switch (frame.type) {
     case PADDING_FRAME:
       break;
     case STREAM_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT,
           base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame));
@@ skipping 75 matching lines @@
     QuicPacketSequenceNumber delta = header.packet_sequence_number -
         largest_received_packet_sequence_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", delta - 1);
     }
     largest_received_packet_sequence_number_ = header.packet_sequence_number;
   }
+  if (header.packet_sequence_number < packets_received_.size())
+    packets_received_[header.packet_sequence_number] = true;
   if (header.packet_sequence_number < last_received_packet_sequence_number_) {
     ++out_of_order_recieved_packet_count_;
     UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderGapReceived",
                          last_received_packet_sequence_number_ -
                              header.packet_sequence_number);
   }
   last_received_packet_sequence_number_ = header.packet_sequence_number;
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
@@ skipping 120 matching lines @@
       base::Bind(&NetLogQuicOnConnectionClosedCallback, error, from_peer));
 }
 
 void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
   string quic_version = QuicVersionToString(version);
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_VERSION_NEGOTIATED,
                     NetLog::StringCallback("version", &quic_version));
 }
 
+base::HistogramBase* QuicConnectionLogger::GetAckHistogram(
+    const char* ack_or_nack) {
+  string prefix("Net.QuicSession.PacketReceived_");
+  const char* suffix = NetworkChangeNotifier::ConnectionTypeToString(
+      connection_type_);
+  return base::LinearHistogram::FactoryGet(prefix + ack_or_nack + suffix, 1,
+      packets_received_.size(), packets_received_.size() + 1,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+}
+
+void QuicConnectionLogger::RecordAckNackHistograms() {
+  if (largest_received_packet_sequence_number_ == 0)
+    return;  // Connection was never used.
+  base::HistogramBase* packet_ack_histogram = GetAckHistogram("Ack_");
+  base::HistogramBase* packet_nack_histogram = GetAckHistogram("Nack_");
+  const QuicPacketSequenceNumber last_index =
+      std::min<QuicPacketSequenceNumber>(
+          packets_received_.size() - 1,
+          largest_received_packet_sequence_number_);
+  // Zero is an invalid packet sequence number.
+  DCHECK(!packets_received_[0]);
+  for (size_t i = 1; i <= last_index; ++i) {
+    if (packets_received_[i])
+      packet_ack_histogram->Add(i);
+    else
+      packet_nack_histogram->Add(i);
+  }
+}
+
 }  // namespace net