Landing Recent QUIC changes until Sun May 8 00:39:29 2016 +0000

net/quic/quic_protocol.cc

 // Copyright (c) 2012 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_protocol.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 115 matching lines @@
     : QuicStreamFrame(stream_id,
                       fin,
                       offset,
                       data.data(),
                       data.length(),
                       nullptr) {}
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
-                                 QuicPacketLength frame_length,
+                                 QuicPacketLength data_length,
                                  UniqueStreamBuffer buffer)
     : QuicStreamFrame(stream_id,
                       fin,
                       offset,
                       nullptr,
-                      frame_length,
+                      data_length,
                       std::move(buffer)) {
   DCHECK(this->buffer != nullptr);
-  DCHECK_EQ(frame_buffer, this->buffer.get());
+  DCHECK_EQ(data_buffer, this->buffer.get());
 }
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
-                                 const char* frame_buffer,
-                                 QuicPacketLength frame_length,
+                                 const char* data_buffer,
+                                 QuicPacketLength data_length,
                                  UniqueStreamBuffer buffer)
     : stream_id(stream_id),
       fin(fin),
-      frame_length(frame_length),
-      frame_buffer(frame_buffer),
+      data_length(data_length),
+      data_buffer(data_buffer),
       offset(offset),
       buffer(std::move(buffer)) {
   if (this->buffer != nullptr) {
-    DCHECK(frame_buffer == nullptr);
-    this->frame_buffer = this->buffer.get();
+    DCHECK(data_buffer == nullptr);
+    this->data_buffer = this->buffer.get();
   }
 }
 
 QuicStreamFrame::~QuicStreamFrame() {}
 
 uint32_t MakeQuicTag(char a, char b, char c, char d) {
   return static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 |
          static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24;
 }
 
@@ skipping 88 matching lines @@
   if (s == Perspective::IS_SERVER) {
     os << "IS_SERVER";
   } else {
     os << "IS_CLIENT";
   }
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
   os << "{ connection_id: " << header.public_header.connection_id
-     << ", connection_id_length:" << header.public_header.connection_id_length
-     << ", packet_number_length:" << header.public_header.packet_number_length
+     << ", connection_id_length: " << header.public_header.connection_id_length
+     << ", packet_number_length: " << header.public_header.packet_number_length
      << ", multipath_flag: " << header.public_header.multipath_flag
      << ", reset_flag: " << header.public_header.reset_flag
      << ", version_flag: " << header.public_header.version_flag;
   if (header.public_header.version_flag) {
-    os << " version: ";
+    os << ", version:";
     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
-      os << header.public_header.versions[i] << " ";
+      os << " ";
+      os << header.public_header.versions[i];
     }
   }
   if (header.public_header.nonce != nullptr) {
     os << ", diversification_nonce: "
-       << QuicUtils::HexEncode(*header.public_header.nonce);
+       << net::QuicUtils::HexDecode(*header.public_header.nonce);
   }
   os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
-     << ", path_id: " << header.path_id
+     << ", path_id: " << static_cast<int>(header.path_id)
      << ", packet_number: " << header.packet_number
-     << ", is_in_fec_group:" << header.is_in_fec_group
-     << ", fec_group: " << header.fec_group << "}\n";
+     << ", is_in_fec_group: " << header.is_in_fec_group
+     << ", fec_group: " << header.fec_group << " }\n";
   return os;
 }
 
 bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketNumber packet_number,
                       QuicPacketNumber peer_least_packet_awaiting_ack) {
   if (ack_frame.missing) {
     return packet_number > ack_frame.largest_observed ||
            ack_frame.packets.Contains(packet_number);
   }
@@ skipping 67 matching lines @@
 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
     : type(WINDOW_UPDATE_FRAME), window_update_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicBlockedFrame* frame)
     : type(BLOCKED_FRAME), blocked_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicPathCloseFrame* frame)
     : type(PATH_CLOSE_FRAME), path_close_frame(frame) {}
 
 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
-  os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
-     << " least_unacked: " << sent_info.least_unacked << "\n";
+  os << "{ entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
+     << ", least_unacked: " << sent_info.least_unacked << " }\n";
   return os;
 }
 
 PacketNumberQueue::const_iterator::const_iterator(
     IntervalSet<QuicPacketNumber>::const_iterator interval_set_iter,
     QuicPacketNumber first,
     QuicPacketNumber last)
     : interval_set_iter_(std::move(interval_set_iter)),
       current_(first),
       last_(last) {}
@@ skipping 161 matching lines @@
 }
 
 ostream& operator<<(ostream& os, const PacketNumberQueue& q) {
   for (QuicPacketNumber packet_number : q) {
     os << packet_number << " ";
   }
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
-  os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
-     << " largest_observed: " << ack_frame.largest_observed
-     << " ack_delay_time: " << ack_frame.ack_delay_time.ToMicroseconds()
-     << " packets: [ " << ack_frame.packets
-     << " ] is_truncated: " << ack_frame.is_truncated
-     << " received_packets: [ ";
+  os << "{ entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
+     << ", largest_observed: " << ack_frame.largest_observed
+     << ", ack_delay_time: " << ack_frame.ack_delay_time.ToMicroseconds()
+     << ", packets: [ " << ack_frame.packets << " ]"
+     << ", is_truncated: " << ack_frame.is_truncated
+     << ", received_packets: [ ";
   for (const std::pair<QuicPacketNumber, QuicTime>& p :
        ack_frame.received_packet_times) {
     os << p.first << " at " << p.second.ToDebuggingValue() << " ";
   }
-  os << " ]\n";
+  os << " ] }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicFrame& frame) {
   switch (frame.type) {
     case PADDING_FRAME: {
-      os << "type { PADDING_FRAME } ";
+      os << "type { PADDING_FRAME } " << frame.padding_frame;
       break;
     }
     case RST_STREAM_FRAME: {
       os << "type { RST_STREAM_FRAME } " << *(frame.rst_stream_frame);
       break;
     }
     case CONNECTION_CLOSE_FRAME: {
       os << "type { CONNECTION_CLOSE_FRAME } "
          << *(frame.connection_close_frame);
       break;
@@ skipping 35 matching lines @@
       break;
     }
     default: {
       LOG(ERROR) << "Unknown frame type: " << frame.type;
       break;
     }
   }
   return os;
 }
 
+ostream& operator<<(ostream& os, const QuicPaddingFrame& padding_frame) {
+  os << "{ num_padding_bytes: " << padding_frame.num_padding_bytes << " }\n";
+  return os;
+}
+
 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) {
-  os << "stream_id { " << rst_frame.stream_id << " } "
-     << "error_code { " << rst_frame.error_code << " }\n";
+  os << "{ stream_id: " << rst_frame.stream_id
+     << ", error_code: " << rst_frame.error_code << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os,
                     const QuicConnectionCloseFrame& connection_close_frame) {
-  os << "error_code { " << connection_close_frame.error_code << " } "
-     << "error_details { " << connection_close_frame.error_details << " }\n";
+  os << "{ error_code: " << connection_close_frame.error_code
+     << ", error_details: '" << connection_close_frame.error_details << "' }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) {
-  os << "error_code { " << goaway_frame.error_code << " } "
-     << "last_good_stream_id { " << goaway_frame.last_good_stream_id << " } "
-     << "reason_phrase { " << goaway_frame.reason_phrase << " }\n";
+  os << "{ error_code: " << goaway_frame.error_code
+     << ", last_good_stream_id: " << goaway_frame.last_good_stream_id
+     << ", reason_phrase: '" << goaway_frame.reason_phrase << "' }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os,
                     const QuicWindowUpdateFrame& window_update_frame) {
-  os << "stream_id { " << window_update_frame.stream_id << " } "
-     << "byte_offset { " << window_update_frame.byte_offset << " }\n";
+  os << "{ stream_id: " << window_update_frame.stream_id
+     << ", byte_offset: " << window_update_frame.byte_offset << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) {
-  os << "stream_id { " << blocked_frame.stream_id << " }\n";
+  os << "{ stream_id: " << blocked_frame.stream_id << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicPathCloseFrame& path_close_frame) {
-  os << "path_id { " << path_close_frame.path_id << " }\n";
+  os << "{ path_id: " << static_cast<int>(path_close_frame.path_id) << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
-  os << "stream_id { " << stream_frame.stream_id << " } "
-     << "fin { " << stream_frame.fin << " } "
-     << "offset { " << stream_frame.offset << " } "
-     << "length { " << stream_frame.frame_length << " }\n";
+  os << "{ stream_id: " << stream_frame.stream_id
+     << ", fin: " << stream_frame.fin << ", offset: " << stream_frame.offset
+     << ", length: " << stream_frame.data_length << " }\n";
   return os;
 }
 
 QuicGoAwayFrame::QuicGoAwayFrame()
     : error_code(QUIC_NO_ERROR), last_good_stream_id(0) {}
 
 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
                                  QuicStreamId last_good_stream_id,
                                  const string& reason)
     : error_code(error_code),
@@ skipping 118 matching lines @@
       encrypted_length(encrypted_length),
       has_crypto_handshake(NOT_HANDSHAKE),
       num_padding_bytes(0),
       path_id(path_id),
       packet_number(packet_number),
       packet_number_length(packet_number_length),
       encryption_level(ENCRYPTION_NONE),
       entropy_hash(entropy_hash),
       has_ack(has_ack),
       has_stop_waiting(has_stop_waiting),
+      original_path_id(kInvalidPathId),
       original_packet_number(0),
       transmission_type(NOT_RETRANSMISSION) {}
 
 SerializedPacket::SerializedPacket(const SerializedPacket& other) = default;
 
 SerializedPacket::~SerializedPacket() {}
 
 TransmissionInfo::TransmissionInfo()
     : encryption_level(ENCRYPTION_NONE),
       packet_number_length(PACKET_1BYTE_PACKET_NUMBER),
@@ skipping 24 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       num_padding_bytes(num_padding_bytes),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net