Land recent QUIC changes.

net/quic/test_tools/quic_test_utils.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/test_tools/quic_test_utils.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_utils.h"
 
@@ skipping 11 matching lines @@
       .WillByDefault(testing::Return(true));
 }
 
 MockFramerVisitor::~MockFramerVisitor() {
 }
 
 bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
   return true;
 }
 
-FramerVisitorCapturingAcks::FramerVisitorCapturingAcks() {
+FramerVisitorCapturingFrames::FramerVisitorCapturingFrames() : frame_count_(0) {
 }
 
-FramerVisitorCapturingAcks::~FramerVisitorCapturingAcks() {
+FramerVisitorCapturingFrames::~FramerVisitorCapturingFrames() {
 }
 
-bool FramerVisitorCapturingAcks::OnPacketHeader(
+bool FramerVisitorCapturingFrames::OnPacketHeader(
     const QuicPacketHeader& header) {
   header_ = header;
+  frame_count_ = 0;
   return true;
 }
 
-void FramerVisitorCapturingAcks::OnAckFrame(const QuicAckFrame& frame) {
-  ack_.reset(new QuicAckFrame(frame));
+void FramerVisitorCapturingFrames::OnStreamFrame(const QuicStreamFrame& frame) {
+  // TODO(ianswett): Own the underlying string, so it will not exist outside
+  // this callback.
+  stream_frames_.push_back(frame);
+  ++frame_count_;
 }
 
-void FramerVisitorCapturingAcks::OnCongestionFeedbackFrame(
+void FramerVisitorCapturingFrames::OnAckFrame(const QuicAckFrame& frame) {
+  ack_.reset(new QuicAckFrame(frame));
+  ++frame_count_;
+}
+
+void FramerVisitorCapturingFrames::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& frame) {
   feedback_.reset(new QuicCongestionFeedbackFrame(frame));
+  ++frame_count_;
+}
+
+void FramerVisitorCapturingFrames::OnRstStreamFrame(
+    const QuicRstStreamFrame& frame) {
+  rst_.reset(new QuicRstStreamFrame(frame));
+  ++frame_count_;
+}
+
+void FramerVisitorCapturingFrames::OnConnectionCloseFrame(
+    const QuicConnectionCloseFrame& frame) {
+  close_.reset(new QuicConnectionCloseFrame(frame));
+  ++frame_count_;
+}
+
+void FramerVisitorCapturingFrames::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+  goaway_.reset(new QuicGoAwayFrame(frame));
+  ++frame_count_;
 }
 
 FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
 }
 
 FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
 }
 
 void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
     const QuicPublicResetPacket& public_reset) {
@@ skipping 40 matching lines @@
     : MockConnection(guid, address) {
 }
 
 PacketSavingConnection::~PacketSavingConnection() {
   STLDeleteElements(&packets_);
 }
 
 bool PacketSavingConnection::SendOrQueuePacket(
     QuicPacketSequenceNumber sequence_number,
     QuicPacket* packet,
-    bool force) {
+    QuicPacketEntropyHash hash) {
   packets_.push_back(packet);
   return true;
 }
 
 MockSession::MockSession(QuicConnection* connection, bool is_server)
     : QuicSession(connection, is_server) {
   ON_CALL(*this, WriteData(_, _, _, _))
       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 }
 
@@ skipping 91 matching lines @@
 static QuicPacket* ConstructPacketFromHandshakeMessage(
     QuicGuid guid,
     const CryptoHandshakeMessage& message) {
   CryptoFramer crypto_framer;
   scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
   QuicFramer quic_framer(QuicDecrypter::Create(kNULL),
                          QuicEncrypter::Create(kNULL));
 
   QuicPacketHeader header;
   header.public_header.guid = guid;
-  header.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
+  header.public_header.reset_flag = false;
+  header.public_header.version_flag = false;
   header.packet_sequence_number = 1;
-  header.private_flags = PACKET_PRIVATE_FLAGS_NONE;
+  header.entropy_flag = false;
+  header.entropy_hash = 0;
+  header.fec_flag = false;
+  header.fec_entropy_flag = false;
   header.fec_group = 0;
 
   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
                                data->AsStringPiece());
 
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
-  return quic_framer.ConstructFrameDataPacket(header, frames);
+  return quic_framer.ConstructFrameDataPacket(header, frames).packet;
 }
 
 QuicPacket* ConstructHandshakePacket(QuicGuid guid, CryptoTag tag) {
   CryptoHandshakeMessage message;
   message.tag = tag;
   return ConstructPacketFromHandshakeMessage(guid, message);
 }
 
 QuicPacket* ConstructClientHelloPacket(QuicGuid guid,
                                        const QuicClock* clock,
@@ skipping 16 matching lines @@
   QuicCryptoNegotiatedParams negotiated_params;
   negotiated_params.SetDefaults();
   string nonce;
   CryptoUtils::GenerateNonce(clock, random_generator, &nonce);
 
   CryptoHandshakeMessage message;
   CryptoUtils::FillServerHelloMessage(negotiated_params, nonce, &message);
   return ConstructPacketFromHandshakeMessage(guid, message);
 }
 
+QuicPacketEntropyHash TestEntropyCalculator::ReceivedEntropyHash(
+    QuicPacketSequenceNumber sequence_number) const {
+  return 1u;
+}
+
 }  // namespace test
 }  // namespace net