Enable FLAGS_quic_reloadable_flag_quic_deprecate_scoped_scheduler2.

R=rch@chromium.org

Change-Id: I95fdbe700abfb4a028037e27dded55c12bf9633d
Reviewed-on: https://chromium-review.googlesource.com/1112050
Commit-Queue: Fan Yang <fayang@chromium.org>
Commit-Queue: Ryan Hamilton <rch@chromium.org>
Reviewed-by: Ryan Hamilton <rch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569713}

net/quic/chromium/quic_http_stream_test.cc

@@ -538,6 +538,25 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<
                                        quic::QUIC_PROMISE_VARY_MISMATCH);
   }
 
+  std::unique_ptr<quic::QuicReceivedPacket>
+  ConstructClientRstStreamVaryMismatchAndRequestHeadersPacket(
+      quic::QuicPacketNumber packet_number,
+      quic::QuicStreamId stream_id,
+      bool should_include_version,
+      bool fin,
+      RequestPriority request_priority,
+      quic::QuicStreamId parent_stream_id,
+      size_t* spdy_headers_frame_length,
+      quic::QuicStreamOffset* offset) {
+    spdy::SpdyPriority priority =
+        ConvertRequestPriorityToQuicPriority(request_priority);
+    return client_maker_.MakeRstAndRequestHeadersPacket(
+        packet_number, should_include_version, promise_id_,
+        quic::QUIC_PROMISE_VARY_MISMATCH, stream_id, fin, priority,
+        std::move(request_headers_), parent_stream_id,
+        spdy_headers_frame_length, offset);
+  }
+
   std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstStreamPacket(
       quic::QuicPacketNumber packet_number,
       quic::QuicPacketNumber largest_received,
@@ -2201,11 +2220,19 @@ TEST_P(QuicHttpStreamTest, ServerPushVaryCheckFail) {
         client_packet_number++, kIncludeVersion, promise_id_, 0,
         DEFAULT_PRIORITY, &header_stream_offset));
   }
-  AddWrite(ConstructClientRstStreamVaryMismatchPacket(client_packet_number++));
-  AddWrite(InnerConstructRequestHeadersPacket(
-      client_packet_number++, stream_id_ + 2, !kIncludeVersion, kFin,
-      DEFAULT_PRIORITY, promise_id_, &spdy_request_header_frame_length,
-      &header_stream_offset));
+  if (FLAGS_quic_reloadable_flag_quic_deprecate_scoped_scheduler2) {
+    AddWrite(ConstructClientRstStreamVaryMismatchAndRequestHeadersPacket(
+        client_packet_number++, stream_id_ + 2, !kIncludeVersion, kFin,
+        DEFAULT_PRIORITY, promise_id_, &spdy_request_header_frame_length,
+        &header_stream_offset));
+  } else {
+    AddWrite(
+        ConstructClientRstStreamVaryMismatchPacket(client_packet_number++));
+    AddWrite(InnerConstructRequestHeadersPacket(
+        client_packet_number++, stream_id_ + 2, !kIncludeVersion, kFin,
+        DEFAULT_PRIORITY, promise_id_, &spdy_request_header_frame_length,
+        &header_stream_offset));
+  }
   AddWrite(ConstructClientAckPacket(client_packet_number++, 3, 1, 1));
   AddWrite(ConstructClientRstStreamCancelledPacket(client_packet_number++));
 

net/quic/chromium/quic_test_packet_maker.cc

@@ -190,6 +190,45 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
   return MakePacket(header, quic::QuicFrame(&rst));
 }
 
+std::unique_ptr<quic::QuicReceivedPacket>
+QuicTestPacketMaker::MakeRstAndRequestHeadersPacket(
+    quic::QuicPacketNumber num,
+    bool include_version,
+    quic::QuicStreamId rst_stream_id,
+    quic::QuicRstStreamErrorCode rst_error_code,
+    quic::QuicStreamId stream_id,
+    bool fin,
+    spdy::SpdyPriority priority,
+    spdy::SpdyHeaderBlock headers,
+    quic::QuicStreamId parent_stream_id,
+    size_t* spdy_headers_frame_length,
+    quic::QuicStreamOffset* offset) {
+  quic::QuicRstStreamFrame rst_frame(1, rst_stream_id, rst_error_code, 0);
+
+  spdy::SpdySerializedFrame spdy_frame = MakeSpdyHeadersFrame(
+      stream_id, fin, priority, std::move(headers), parent_stream_id);
+  if (spdy_headers_frame_length) {
+    *spdy_headers_frame_length = spdy_frame.size();
+  }
+  quic::QuicStreamOffset header_offset = 0;
+  if (offset != nullptr) {
+    header_offset = *offset;
+    *offset += spdy_frame.size();
+  }
+  quic::QuicStreamFrame headers_frame(
+      quic::kHeadersStreamId, false, header_offset,
+      quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+
+  quic::QuicFrames frames;
+  frames.push_back(quic::QuicFrame(&rst_frame));
+  DVLOG(1) << "Adding frame: " << frames.back();
+  frames.push_back(quic::QuicFrame(&headers_frame));
+  DVLOG(1) << "Adding frame: " << frames.back();
+
+  InitializeHeader(num, include_version);
+  return MakeMultipleFramesPacket(header_, frames);
+}
+
 std::unique_ptr<quic::QuicReceivedPacket>
 QuicTestPacketMaker::MakeAckAndRstPacket(
     quic::QuicPacketNumber num,

net/quic/chromium/quic_test_packet_maker.h

@@ -74,6 +74,19 @@ class QuicTestPacketMaker {
       quic::QuicRstStreamErrorCode error_code,
       size_t bytes_written);
 
+  std::unique_ptr<quic::QuicReceivedPacket> MakeRstAndRequestHeadersPacket(
+      quic::QuicPacketNumber num,
+      bool include_version,
+      quic::QuicStreamId rst_stream_id,
+      quic::QuicRstStreamErrorCode rst_error_code,
+      quic::QuicStreamId stream_id,
+      bool fin,
+      spdy::SpdyPriority priority,
+      spdy::SpdyHeaderBlock headers,
+      quic::QuicStreamId parent_stream_id,
+      size_t* spdy_headers_frame_length,
+      quic::QuicStreamOffset* offset);
+
   std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndRstPacket(
       quic::QuicPacketNumber num,
       bool include_version,

net/third_party/quic/core/quic_flags_list.h

@@ -156,7 +156,7 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr_slower_startup2, true)
 // ScopedPacketFlusher.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_deprecate_scoped_scheduler2,
-          false)
+          true)
 
 // If it's been more than SRTT since receiving a packet, set the ack alarm for
 // 1ms instead of the standard delayed ack timer.