Land recent QUIC changes.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 12 matching lines @@
   dict->SetString("peer_address", peer_address->ToString());
   dict->SetInteger("size", packet_size);
   return dict;
 }
 
 Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header,
                                       NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString("guid",
                   base::Uint64ToString(header->public_header.guid));
-  dict->SetInteger("public_flags", header->public_header.flags);
+  dict->SetInteger("reset_flag", header->public_header.reset_flag);
+  dict->SetInteger("version_flag", header->public_header.version_flag);
   dict->SetString("packet_sequence_number",
                   base::Uint64ToString(header->packet_sequence_number));
-  dict->SetInteger("private_flags", header->private_flags);
+  dict->SetInteger("entropy_flag", header->entropy_flag);
+  dict->SetInteger("fec_flag", header->fec_flag);
+  dict->SetInteger("fec_entropy_flag", header->fec_entropy_flag);
   dict->SetInteger("fec_group", header->fec_group);
   return dict;
 }
 
 Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame,
                                      NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetBoolean("fin", frame->fin);
   dict->SetString("offset", base::Uint64ToString(frame->offset));
   dict->SetInteger("length", frame->data.length());
   return dict;
 }
 
 Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame,
                                   NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   DictionaryValue* sent_info = new DictionaryValue();
   dict->Set("sent_info", sent_info);
   sent_info->SetString("least_unacked",
                        base::Uint64ToString(frame->sent_info.least_unacked));
   DictionaryValue* received_info = new DictionaryValue();
   dict->Set("received_info", received_info);
   received_info->SetString(
       "largest_observed",
       base::Uint64ToString(frame->received_info.largest_observed));
   ListValue* missing = new ListValue();
   received_info->Set("missing_packets", missing);
-  const SequenceSet& missing_packets = frame->received_info.missing_packets;
-  for (SequenceSet::const_iterator it = missing_packets.begin();
+  const SequenceNumberSet& missing_packets =
+      frame->received_info.missing_packets;
+  for (SequenceNumberSet::const_iterator it = missing_packets.begin();
        it != missing_packets.end(); ++it) {
     missing->Append(new base::StringValue(base::Uint64ToString(*it)));
   }
   return dict;
 }
 
 Value* NetLogQuicCongestionFeedbackFrameCallback(
     const QuicCongestionFeedbackFrame* frame,
     NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
@@ skipping 26 matching lines @@
       break;
   }
 
   return dict;
 }
 
 Value* NetLogQuicRstStreamFrameCallback(const QuicRstStreamFrame* frame,
                                         NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
-  dict->SetInteger("offset", frame->offset);
   dict->SetInteger("error_code", frame->error_code);
   dict->SetString("details", frame->error_details);
   return dict;
 }
 
 Value* NetLogQuicConnectionCloseFrameCallback(
     const QuicConnectionCloseFrame* frame,
     NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("error_code", frame->error_code);
@@ skipping 61 matching lines @@
 void QuicConnectionLogger::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
 }
 
 void QuicConnectionLogger::OnRevivedPacket(
     const QuicPacketHeader& revived_header,
     base::StringPiece payload) {
 }
 
 }  // namespace net