Add new histogram Net.QuicSession.DuplicateStreamFramePercent

for reporting the number of duplicate QUIC stream frames
received.

Review URL: https://codereview.chromium.org/227463007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@262315 0039d316-1c4b-4281-b951-d872f2087c98

net/quic/quic_client_session.cc

@@ -436,6 +436,12 @@ QuicDataStream* QuicClientSession::CreateIncomingDataStream(
 }
 
 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
+  ReliableQuicStream* stream = GetStream(stream_id);
+  if (stream) {
+    logger_.UpdateReceivedFrameCounts(
+        stream_id, stream->num_frames_received(),
+        stream->num_duplicate_frames_received());
+  }
   QuicSession::CloseStream(stream_id);
   OnClosedStream();
 }

net/quic/quic_connection_logger.cc

@@ -309,6 +309,8 @@ QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
       num_packets_received_(0),
       num_truncated_acks_sent_(0),
       num_truncated_acks_received_(0),
+      num_frames_received_(0),
+      num_duplicate_frames_received_(0),
       connection_description_(GetConnectionDescriptionString()) {
 }
 
@@ -319,6 +321,19 @@ QuicConnectionLogger::~QuicConnectionLogger() {
                        num_truncated_acks_sent_);
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.TruncatedAcksReceived",
                        num_truncated_acks_received_);
+  if (num_frames_received_ > 0) {
+    int duplicate_stream_frame_percent =
+        num_duplicate_frames_received_ * 100 / num_frames_received_;
+    if (num_packets_received_ < 100) {
+      UMA_HISTOGRAM_COUNTS(
+          "Net.QuicSession.StreamFrameDuplicatedPercentShortConnection",
+          duplicate_stream_frame_percent);
+    } else {
+      UMA_HISTOGRAM_COUNTS(
+          "Net.QuicSession.StreamFrameDuplicatedPercentLongConnection",
+          duplicate_stream_frame_percent);
+    }
+  }
 
   RecordLossHistograms();
 }
@@ -591,6 +606,16 @@ void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
                     NetLog::StringCallback("version", &quic_version));
 }
 
+void QuicConnectionLogger::UpdateReceivedFrameCounts(
+    QuicStreamId stream_id,
+    int num_frames_received,
+    int num_duplicate_frames_received) {
+  if (stream_id != kCryptoStreamId) {
+    num_frames_received_ += num_frames_received;
+    num_duplicate_frames_received_ += num_duplicate_frames_received;
+  }
+}
+
 base::HistogramBase* QuicConnectionLogger::GetPacketSequenceNumberHistogram(
     const char* statistic_name) const {
   string prefix("Net.QuicSession.PacketReceived_");

net/quic/quic_connection_logger.h

@@ -63,6 +63,9 @@ class NET_EXPORT_PRIVATE QuicConnectionLogger
       const CryptoHandshakeMessage& message);
   void OnConnectionClosed(QuicErrorCode error, bool from_peer);
   void OnSuccessfulVersionNegotiation(const QuicVersion& version);
+  void UpdateReceivedFrameCounts(QuicStreamId stream_id,
+                                 int num_frames_received,
+                                 int num_duplicate_frames_received);
 
  private:
   // Do a factory get for a histogram for recording data, about individual
@@ -123,6 +126,10 @@ class NET_EXPORT_PRIVATE QuicConnectionLogger
   size_t num_truncated_acks_received_;
   // The kCADR value provided by the server in ServerHello.
   IPEndPoint client_address_;
+  // Count of the number of frames received.
+  int num_frames_received_;
+  // Count of the number of duplicate frames received.
+  int num_duplicate_frames_received_;
   // Vector of inital packets status' indexed by packet sequence numbers, where
   // false means never received.  Zero is not a valid packet sequence number, so
   // that offset is never used, and we'll track 150 packets.

net/quic/quic_stream_sequencer.cc

@@ -8,6 +8,7 @@
 #include <limits>
 
 #include "base/logging.h"
+#include "base/metrics/sparse_histogram.h"
 #include "net/quic/reliable_quic_stream.h"
 
 using std::min;
@@ -21,7 +22,9 @@ QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream)
       max_frame_memory_(numeric_limits<size_t>::max()),
       close_offset_(numeric_limits<QuicStreamOffset>::max()),
       blocked_(false),
-      num_bytes_buffered_(0) {
+      num_bytes_buffered_(0),
+      num_frames_received_(0),
+      num_duplicate_frames_received_(0) {
 }
 
 QuicStreamSequencer::QuicStreamSequencer(size_t max_frame_memory,
@@ -31,7 +34,9 @@ QuicStreamSequencer::QuicStreamSequencer(size_t max_frame_memory,
       max_frame_memory_(max_frame_memory),
       close_offset_(numeric_limits<QuicStreamOffset>::max()),
       blocked_(false),
-      num_bytes_buffered_(0) {
+      num_bytes_buffered_(0),
+      num_frames_received_(0),
+      num_duplicate_frames_received_(0) {
   if (max_frame_memory < kMaxPacketSize) {
     LOG(DFATAL) << "Setting max frame memory to " << max_frame_memory
                 << ".  Some frames will be impossible to handle.";
@@ -72,12 +77,14 @@ bool QuicStreamSequencer::WillAcceptStreamFrame(
 }
 
 bool QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
+  ++num_frames_received_;
   if (!WillAcceptStreamFrame(frame)) {
     // This should not happen, as WillAcceptFrame should be called before
     // OnStreamFrame.  Error handling should be done by the caller.
     return false;
   }
   if (IsDuplicate(frame)) {
+    ++num_duplicate_frames_received_;
     // Silently ignore duplicates.
     return true;
   }

net/quic/quic_stream_sequencer.h

@@ -76,6 +76,10 @@ class NET_EXPORT_PRIVATE QuicStreamSequencer {
   size_t num_bytes_buffered() const { return num_bytes_buffered_; }
   QuicStreamOffset num_bytes_consumed() const { return num_bytes_consumed_; }
 
+  int num_frames_received() { return num_frames_received_; }
+
+  int num_duplicate_frames_received() { return num_duplicate_frames_received_; }
+
  private:
   friend class test::QuicStreamSequencerPeer;
 
@@ -115,6 +119,12 @@ class NET_EXPORT_PRIVATE QuicStreamSequencer {
 
   // Tracks how many bytes the sequencer has buffered.
   size_t num_bytes_buffered_;
+
+  // Count of the number of frames received.
+  int num_frames_received_;
+
+  // Count of the number of duplicate frames received.
+  int num_duplicate_frames_received_;
 };
 
 }  // namespace net

net/quic/reliable_quic_stream.cc

@@ -210,6 +210,14 @@ void ReliableQuicStream::MaybeSendWindowUpdate() {
   }
 }
 
+int ReliableQuicStream::num_frames_received() {
+  return sequencer_.num_frames_received();
+}
+
+int ReliableQuicStream::num_duplicate_frames_received() {
+  return sequencer_.num_duplicate_frames_received();
+}
+
 void ReliableQuicStream::OnStreamReset(const QuicRstStreamFrame& frame) {
   stream_error_ = frame.error_code;
   CloseWriteSide();

net/quic/reliable_quic_stream.h

@@ -104,6 +104,10 @@ class NET_EXPORT_PRIVATE ReliableQuicStream {
   // sequencer's buffer.
   void MaybeSendWindowUpdate();
 
+  int num_frames_received();
+
+  int num_duplicate_frames_received();
+
  protected:
   // Sends as much of 'data' to the connection as the connection will consume,
   // and then buffers any remaining data in queued_data_.

tools/metrics/histograms/histograms.xml

@@ -12793,6 +12793,22 @@ other types of suffix sets.
   </summary>
 </histogram>
 
+<histogram name="Net.QuicSession.StreamFrameDuplicatedPercentLongConnection">
+  <owner>rch@chromium.org</owner>
+  <summary>
+    The percentage of stream frames received which were duplicates. Only for
+    QUIC sessions which received at least 100 packets.
+  </summary>
+</histogram>
+
+<histogram name="Net.QuicSession.StreamFrameDuplicatedPercentShortConnection">
+  <owner>rch@chromium.org</owner>
+  <summary>
+    The percentage of stream frames received which were duplicates. Only for
+    QUIC sessions which received fewer than 100 packets.
+  </summary>
+</histogram>
+
 <histogram name="Net.QuicSession.TruncatedAcksReceived">
   <owner>rch@chromium.org</owner>
   <summary>The number of truncated ACK frames received.</summary>