Migrates QUIC sessions to a new network when old network is (about to be) disconnected.

net/quic/test_tools/quic_test_packet_maker.cc

 // Copyright 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/test_tools/quic_test_packet_maker.h"
 
 #include <list>
 
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
@@ skipping 15 matching lines @@
       host_(host),
       spdy_request_framer_(HTTP2),
       spdy_response_framer_(HTTP2) {}
 
 QuicTestPacketMaker::~QuicTestPacketMaker() {}
 
 void QuicTestPacketMaker::set_hostname(const std::string& host) {
   host_.assign(host);
 }
 
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakePingPacket(
+    QuicPacketNumber num,
+    bool include_version) {
+  QuicPacketHeader header;
+  header.public_header.connection_id = connection_id_;
+  header.public_header.reset_flag = false;
+  header.public_header.version_flag = include_version;
+  header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
+  header.packet_number = num;
+  header.entropy_flag = false;
+  header.fec_flag = false;
+  header.fec_group = 0;
+
+  QuicPingFrame ping;
+  return scoped_ptr<QuicEncryptedPacket>(MakePacket(header, QuicFrame(ping)));
+}
+
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket(
     QuicPacketNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
@@ skipping 167 matching lines @@
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     QuicStreamOffset offset,
     base::StringPiece data) {
   InitializeHeader(packet_number, should_include_version);
   QuicStreamFrame frame(stream_id, fin, offset, data);
   return MakePacket(header_, QuicFrame(&frame));
 }
 
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
+    QuicPacketNumber packet_number,
+    bool include_version,
+    QuicStreamId stream_id,
+    QuicPacketNumber largest_received,
+    QuicPacketNumber least_unacked,
+    bool fin,
+    QuicStreamOffset offset,
+    base::StringPiece data) {
+  InitializeHeader(packet_number, include_version);
+
+  QuicAckFrame ack(MakeAckFrame(largest_received));
+  ack.delta_time_largest_observed = QuicTime::Delta::Zero();
+  for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
+    ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
+  }
+  QuicFrames frames;
+  frames.push_back(QuicFrame(&ack));
+
+  QuicStopWaitingFrame stop_waiting;
+  stop_waiting.least_unacked = least_unacked;
+  frames.push_back(QuicFrame(&stop_waiting));
+
+  QuicStreamFrame stream_frame(stream_id, fin, offset, data);
+  frames.push_back(QuicFrame(&stream_frame));
+
+  return MakeMultipleFramesPacket(header_, frames);
+}
+
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
     const SpdyHeaderBlock& headers,
     size_t* spdy_headers_frame_length) {
   InitializeHeader(packet_number, should_include_version);
   scoped_ptr<SpdySerializedFrame> spdy_frame;
@@ skipping 87 matching lines @@
     const std::string& status) {
   SpdyHeaderBlock headers;
   headers[":status"] = status;
   headers["content-type"] = "text/plain";
   return headers;
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakePacket(
     const QuicPacketHeader& header,
     const QuicFrame& frame) {
+  QuicFrames frames;
+  frames.push_back(frame);
+  return MakeMultipleFramesPacket(header, frames);
+}
+
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeMultipleFramesPacket(
+    const QuicPacketHeader& header,
+    const QuicFrames& frames) {
   QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(),
                     Perspective::IS_CLIENT);
-  QuicFrames frames;
-  frames.push_back(frame);
   scoped_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
   size_t encrypted_size = framer.EncryptPayload(
       ENCRYPTION_NONE, header.packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicEncryptedPacket encrypted(buffer, encrypted_size, false);
   return scoped_ptr<QuicEncryptedPacket>(encrypted.Clone());
 }
 
 void QuicTestPacketMaker::InitializeHeader(QuicPacketNumber packet_number,
                                            bool should_include_version) {
   header_.public_header.connection_id = connection_id_;
   header_.public_header.reset_flag = false;
   header_.public_header.version_flag = should_include_version;
   header_.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header_.packet_number = packet_number;
   header_.fec_group = 0;
   header_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 }  // namespace test
 }  // namespace net