QUIC - expand server push test coverage and fix recent regression.

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 <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 249 matching lines @@
   for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
   if (largest_received > 0 && version_ > QUIC_VERSION_33) {
     ack.missing = false;
     ack.packets.Add(1, largest_received + 1);
   }
 
   QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
   QuicFrames frames;
-  frames.push_back(QuicFrame(&ack));
+  QuicFrame ack_frame(&ack);
+  DVLOG(1) << "Adding frame: " << ack_frame;
+  frames.push_back(ack_frame);
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = stop_least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
 
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
   size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
                                                 header.packet_number, *packet,
@@ skipping 196 matching lines @@
     SpdyPriority priority,
     SpdyHeaderBlock headers,
     QuicStreamOffset* offset) {
   return MakeRequestHeadersPacket(packet_number, stream_id,
                                   should_include_version, fin, priority,
                                   std::move(headers), nullptr, offset);
 }
 
 // If |offset| is provided, will use the value when creating the packet.
 // Will also update the value after packet creation.
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePushPromisePacket(
+    QuicPacketNumber packet_number,
+    QuicStreamId stream_id,
+    QuicStreamId promised_stream_id,
+    bool should_include_version,
+    bool fin,
+    SpdyHeaderBlock headers,
+    size_t* spdy_headers_frame_length,
+    QuicStreamOffset* offset) {
+  InitializeHeader(packet_number, should_include_version);
+  SpdySerializedFrame spdy_frame;
+  SpdyPushPromiseIR promise_frame(stream_id, promised_stream_id,
+                                  std::move(headers));
+  promise_frame.set_fin(fin);
+  spdy_frame = spdy_request_framer_.SerializeFrame(promise_frame);
+  if (spdy_headers_frame_length) {
+    *spdy_headers_frame_length = spdy_frame.size();
+  }
+  if (offset != nullptr) {
+    QuicStreamFrame frame(
+        kHeadersStreamId, false, *offset,
+        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+    *offset += spdy_frame.size();
+    return MakePacket(header_, QuicFrame(&frame));
+  } else {
+    QuicStreamFrame frame(
+        kHeadersStreamId, false, 0,
+        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+    return MakePacket(header_, QuicFrame(&frame));
+  }
+}
+
+// If |offset| is provided, will use the value when creating the packet.
+// Will also update the value after packet creation.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length,
     QuicStreamOffset* offset) {
   InitializeHeader(packet_number, should_include_version);
@@ skipping 111 matching lines @@
   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_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 }  // namespace test
 }  // namespace net