Land recent QUIC changes.

net/quic/quic_stream_factory_test.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_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/string_util.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
@@ skipping 20 matching lines @@
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructChlo() {
     const std::string& host = host_port_proxy_pair_.first.host();
     scoped_ptr<QuicPacket> chlo(ConstructClientHelloPacket(0xDEADBEEF,
                                                            clock_,
                                                            &random_generator_,
                                                            host));
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*chlo));
+    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *chlo));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructShlo() {
     scoped_ptr<QuicPacket> shlo(ConstructHandshakePacket(0xDEADBEEF, kSHLO));
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*shlo));
+    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *shlo));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
-    header.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
+    header.public_header.reset_flag = false;
+    header.public_header.version_flag = false;
     header.packet_sequence_number = num;
-    header.private_flags = PACKET_PRIVATE_FLAGS_NONE;
+    header.entropy_flag = false;
+    header.fec_entropy_flag = false;
+    header.fec_flag = false;
     header.fec_group = 0;
 
-    QuicRstStreamFrame rst(stream_id, 0, QUIC_NO_ERROR);
+    QuicRstStreamFrame rst(stream_id, QUIC_NO_ERROR);
     return scoped_ptr<QuicEncryptedPacket>(
         ConstructPacket(header, QuicFrame(&rst)));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
-    header.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
+    header.public_header.reset_flag = false;
+    header.public_header.version_flag = false;
     header.packet_sequence_number = 2;
-    header.private_flags = PACKET_PRIVATE_FLAGS_NONE;
+    header.entropy_flag = false;
+    header.fec_entropy_flag = false;
+    header.fec_flag = false;
     header.fec_group = 0;
 
     QuicAckFrame ack(largest_received, least_unacked);
-
     QuicCongestionFeedbackFrame feedback;
     feedback.type = kTCP;
     feedback.tcp.accumulated_number_of_lost_packets = 0;
     feedback.tcp.receive_window = 16000;
 
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     QuicFrames frames;
     frames.push_back(QuicFrame(&ack));
     frames.push_back(QuicFrame(&feedback));
     scoped_ptr<QuicPacket> packet(
-        framer.ConstructFrameDataPacket(header, frames));
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*packet));
+        framer.ConstructFrameDataPacket(header, frames).packet);
+    return scoped_ptr<QuicEncryptedPacket>(
+        framer.EncryptPacket(header.packet_sequence_number, *packet));
   }
 
   // Returns a newly created packet to send congestion feedback data.
   scoped_ptr<QuicEncryptedPacket> ConstructFeedbackPacket(
       QuicPacketSequenceNumber sequence_number) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
-    header.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
+    header.public_header.reset_flag = false;
+    header.public_header.version_flag = false;
     header.packet_sequence_number = sequence_number;
-    header.private_flags = PACKET_PRIVATE_FLAGS_NONE;
+    header.entropy_flag = false;
+    header.fec_entropy_flag = false;
+    header.fec_flag = false;
     header.fec_group = 0;
 
     QuicCongestionFeedbackFrame frame;
     frame.type = kTCP;
     frame.tcp.accumulated_number_of_lost_packets = 0;
     frame.tcp.receive_window = 16000;
 
     return scoped_ptr<QuicEncryptedPacket>(
         ConstructPacket(header, QuicFrame(&frame)));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructPacket(
       const QuicPacketHeader& header,
       const QuicFrame& frame) {
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     QuicFrames frames;
     frames.push_back(frame);
     scoped_ptr<QuicPacket> packet(
-        framer.ConstructFrameDataPacket(header, frames));
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*packet));
+        framer.ConstructFrameDataPacket(header, frames).packet);
+    return scoped_ptr<QuicEncryptedPacket>(
+        framer.EncryptPacket(header.packet_sequence_number, *packet));
   }
 
   MockHostResolver host_resolver_;
   MockClientSocketFactory socket_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by factory_.
   QuicStreamFactory factory_;
   HostPortProxyPair host_port_proxy_pair_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
@@ skipping 146 matching lines @@
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net