Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/chromium/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/chromium/quic_connection_logger.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 95 matching lines @@
 }
 
 std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
     const QuicAckFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("largest_observed",
                   base::Uint64ToString(frame->largest_observed));
   dict->SetString("delta_time_largest_observed_us",
                   base::Int64ToString(frame->ack_delay_time.ToMicroseconds()));
-  if (frame->missing) {
-    // Entropy and Truncated are not present in v34 and above.
-    dict->SetInteger("entropy_hash", frame->entropy_hash);
-    dict->SetBoolean("truncated", frame->is_truncated);
-  }
 
   base::ListValue* missing = new base::ListValue();
   dict->Set("missing_packets", missing);
-  if (frame->missing) {
-    for (const Interval<QuicPacketNumber>& interval : frame->packets) {
-      for (QuicPacketNumber packet = interval.min(); packet < interval.max();
-           ++packet) {
-        missing->AppendString(base::Uint64ToString(packet));
-      }
-    }
-  } else if (!frame->packets.Empty()) {
+  if (!frame->packets.Empty()) {
     // V34 and above express acked packets, but only print
     // missing packets, because it's typically a shorter list.
     for (QuicPacketNumber packet = frame->packets.Min();
          packet < frame->largest_observed; ++packet) {
       if (!frame->packets.Contains(packet)) {
         missing->AppendString(base::Uint64ToString(packet));
       }
     }
   }
 
@@ skipping 120 matching lines @@
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   base::ListValue* subjects = new base::ListValue();
   for (std::vector<std::string>::const_iterator it = dns_names.begin();
        it != dns_names.end(); it++) {
     subjects->AppendString(*it);
   }
   dict->Set("subjects", subjects);
   return std::move(dict);
 }
 
-void UpdatePacketGapSentHistogram(size_t num_consecutive_missing_packets) {
-  UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapSent",
-                       num_consecutive_missing_packets);
-}
-
 void UpdatePublicResetAddressMismatchHistogram(
     const IPEndPoint& server_hello_address,
     const IPEndPoint& public_reset_address) {
   int sample = GetAddressMismatch(server_hello_address, public_reset_address);
   // We are seemingly talking to an older server that does not support the
   // feature, so we can't report the results in the histogram.
   if (sample < 0) {
     return;
   }
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.PublicResetAddressMismatch2",
@@ skipping 14 matching lines @@
     const char* const connection_description,
     std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     const NetLogWithSource& net_log)
     : net_log_(net_log),
       session_(session),
       last_received_packet_number_(0),
       last_received_packet_size_(0),
       no_packet_received_after_ping_(false),
       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_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),
@@ skipping 221 matching lines @@
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_number_ < received_acks_.size() &&
       last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
     received_acks_[static_cast<size_t>(last_received_packet_number_)] = true;
   }
 
   if (frame.packets.Empty())
     return;
 
   // TODO(rch, rtenneti) sort out histograms for QUIC_VERSION_34 and above.
-  if (session_->connection()->version() > QUIC_VERSION_33) {
-    return;
-  }
-  const PacketNumberQueue& missing_packets = frame.packets;
-  PacketNumberQueue::const_iterator it =
-      missing_packets.lower_bound(largest_received_missing_packet_number_);
-  if (it == missing_packets.end() ||
-      largest_received_missing_packet_number_ == missing_packets.Max()) {
-    return;
-  }
-
-  // Scan through the list and log consecutive ranges of missing packets.
-  size_t num_consecutive_missing_packets = 1;
-  QuicPacketNumber previous_missing_packet =
-      largest_received_missing_packet_number_;
-  for (; it != missing_packets.end(); ++it) {
-    // Account for case where first interval starts below
-    // largest_received_missing_packet_number_.
-    QuicPacketNumber interval_min =
-        std::max(previous_missing_packet + 1, it->min());
-    DCHECK_LE(interval_min, it->max());
-
-    size_t interval_len = it->max() - interval_min;
-    if (interval_len == 0) {
-      continue;
-    }
-    if (interval_min == previous_missing_packet + 1) {
-      num_consecutive_missing_packets += interval_len;
-    } else {
-      UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
-      num_consecutive_missing_packets = interval_len;
-    }
-    previous_missing_packet = it->max() - 1;
-  }
-  UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
-  largest_received_missing_packet_number_ = missing_packets.Max();
 }
 
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
   net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeServer",
@@ skipping 155 matching lines @@
 
   string prefix("Net.QuicSession.PacketLossRate_");
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       prefix + connection_description_, 1, 1000, 75,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<base::HistogramBase::Sample>(
       ReceivedPacketLossRate() * 1000));
 }
 
 }  // namespace net