Roll src/net/third_party/quiche/src/ 014740d30..7498c8c59 (1 commit)

https://quiche.googlesource.com/quiche.git/+log/014740d30571..7498c8c59b8a

$ git log 014740d30..7498c8c59 --date=short --no-merges --format='%ad %ae %s'
2019-07-02 renjietang In HTTP/3, write Priority on control stream before writing headers.

Created with:
  roll-dep src/net/third_party/quiche/src

[Reland https://chromium-review.googlesource.com/c/chromium/src/+/1691429]

Bug: 982169
Change-Id: I8ecb5b77439e02965371a5d15d716f04b57f2e83
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1692963
Commit-Queue: Ryan Hamilton <rch@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Auto-Submit: Ryan Hamilton <rch@chromium.org>
Reviewed-by: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#675758}

DEPS

@@ -281,7 +281,7 @@ vars = {
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'quiche_revision': '014740d305715301a61e322f254aa2819c323349',
+  'quiche_revision': '7498c8c59b8a8ea83db9368a889323bd0b146544',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ios_webkit
   # and whatever else without interference from each other.

net/quic/quic_test_packet_maker.cc

@@ -350,12 +350,52 @@ QuicTestPacketMaker::MakeRstAndRequestHeadersPacket(
   }
 
   if (quic::VersionUsesQpack(version_.transport_version)) {
+    // A stream frame containing stream type will be written on the control
+    // stream first.
+    std::string type(1, 0x00);
+
+    quic::SettingsFrame settings;
+    settings.values[quic::kSettingsMaxHeaderListSize] =
+        quic::kDefaultMaxUncompressedHeaderSize;
+    std::unique_ptr<char[]> buffer1;
+    quic::QuicByteCount frame_length1 =
+        http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+    std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+    quic::QuicStreamFrame type_frame;
+    quic::QuicStreamFrame settings_frame;
+    if (stream_offsets_[2] == 0) {
+      type_frame = GenerateNextStreamFrame(2, false, type);
+      frames.push_back(quic::QuicFrame(type_frame));
+      settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+      frames.push_back(quic::QuicFrame(settings_frame));
+    }
+
+    quic::PriorityFrame frame;
+    frame.weight = priority;
+    frame.dependency_type = quic::ROOT_OF_TREE;
+    frame.prioritized_type = quic::REQUEST_STREAM;
+    frame.prioritized_element_id = stream_id;
+
+    std::unique_ptr<char[]> buffer;
+    quic::QuicByteCount frame_length =
+        http_encoder_.SerializePriorityFrame(frame, &buffer);
+    std::string priority_data = std::string(buffer.get(), frame_length);
+
+    quic::QuicStreamFrame priority_frame =
+        GenerateNextStreamFrame(2, false, priority_data);
+
+    frames.push_back(quic::QuicFrame(priority_frame));
+
+    // STREAM frames for HEADERS.
     std::vector<std::string> data = QpackEncodeHeaders(
         stream_id, std::move(headers), spdy_headers_frame_length);
     std::vector<quic::QuicStreamFrame> stream_frames =
         GenerateNextStreamFrames(stream_id, fin, data);
+
     for (const auto& frame : stream_frames)
       frames.push_back(quic::QuicFrame(frame));
+
     InitializeHeader(num, include_version);
     return MakeMultipleFramesPacket(header_, frames, nullptr);
   }
@@ -763,6 +803,42 @@ QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
     const std::vector<std::string>& data_writes) {
   InitializeHeader(packet_number, should_include_version);
   if (quic::VersionUsesQpack(version_.transport_version)) {
+    // A stream frame containing stream type will be written on the control
+    // stream first.
+    std::string type(1, 0x00);
+
+    quic::SettingsFrame settings;
+    settings.values[quic::kSettingsMaxHeaderListSize] =
+        quic::kDefaultMaxUncompressedHeaderSize;
+    std::unique_ptr<char[]> buffer1;
+    quic::QuicByteCount frame_length1 =
+        http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+    std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+    quic::QuicStreamFrame type_frame;
+    quic::QuicStreamFrame settings_frame;
+    quic::QuicFrames frames;
+    if (stream_offsets_[2] == 0) {
+      type_frame = GenerateNextStreamFrame(2, false, type);
+      frames.push_back(quic::QuicFrame(type_frame));
+      settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+      frames.push_back(quic::QuicFrame(settings_frame));
+    }
+
+    quic::PriorityFrame frame;
+    frame.weight = priority;
+    frame.dependency_type = quic::ROOT_OF_TREE;
+    frame.prioritized_type = quic::REQUEST_STREAM;
+    frame.prioritized_element_id = stream_id;
+
+    std::unique_ptr<char[]> buffer;
+    quic::QuicByteCount frame_length =
+        http_encoder_.SerializePriorityFrame(frame, &buffer);
+    std::string priority_data = std::string(buffer.get(), frame_length);
+
+    quic::QuicStreamFrame priority_frame =
+        GenerateNextStreamFrame(2, false, priority_data);
+
     // STREAM frames for HEADERS.
     std::vector<std::string> data = QpackEncodeHeaders(
         stream_id, std::move(headers), spdy_headers_frame_length);
@@ -776,9 +852,11 @@ QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
           stream_id, is_fin, quic::QuicStringPiece(data_writes[i])));
     }
 
-    quic::QuicFrames frames;
+    frames.push_back(quic::QuicFrame(priority_frame));
+
     for (const auto& frame : stream_frames)
       frames.push_back(quic::QuicFrame(frame));
+
     return MakeMultipleFramesPacket(header_, frames, nullptr);
   }
 
@@ -820,12 +898,49 @@ QuicTestPacketMaker::MakeRequestHeadersPacket(
   InitializeHeader(packet_number, should_include_version);
 
   if (quic::VersionUsesQpack(version_.transport_version)) {
+    // A stream frame containing stream type will be written on the control
+    // stream first.
+    std::string type(1, 0x00);
+
+    quic::SettingsFrame settings;
+    settings.values[quic::kSettingsMaxHeaderListSize] =
+        quic::kDefaultMaxUncompressedHeaderSize;
+    std::unique_ptr<char[]> buffer1;
+    quic::QuicByteCount frame_length1 =
+        http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+    std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+    quic::QuicStreamFrame type_frame;
+    quic::QuicStreamFrame settings_frame;
+    quic::QuicFrames frames;
+    if (stream_offsets_[2] == 0) {
+      type_frame = GenerateNextStreamFrame(2, false, type);
+      frames.push_back(quic::QuicFrame(type_frame));
+      settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+      frames.push_back(quic::QuicFrame(settings_frame));
+    }
+
+    quic::PriorityFrame frame;
+    frame.weight = priority;
+    frame.dependency_type = quic::ROOT_OF_TREE;
+    frame.prioritized_type = quic::REQUEST_STREAM;
+    frame.prioritized_element_id = stream_id;
+
+    std::unique_ptr<char[]> buffer;
+    quic::QuicByteCount frame_length =
+        http_encoder_.SerializePriorityFrame(frame, &buffer);
+    std::string priority_data = std::string(buffer.get(), frame_length);
+
+    quic::QuicStreamFrame priority_frame =
+        GenerateNextStreamFrame(2, false, priority_data);
+
     std::vector<std::string> data = QpackEncodeHeaders(
         stream_id, std::move(headers), spdy_headers_frame_length);
     std::vector<quic::QuicStreamFrame> stream_frames =
         GenerateNextStreamFrames(stream_id, fin, data);
 
-    quic::QuicFrames frames;
+    frames.push_back(quic::QuicFrame(priority_frame));
+
     for (const auto& frame : stream_frames)
       frames.push_back(quic::QuicFrame(frame));
     return MakeMultipleFramesPacket(header_, frames, nullptr);
@@ -855,13 +970,49 @@ QuicTestPacketMaker::MakeRequestHeadersAndRstPacket(
     size_t* spdy_headers_frame_length,
     quic::QuicRstStreamErrorCode error_code) {
   if (quic::VersionUsesQpack(version_.transport_version)) {
-    // STREAM frames for HEADERS.
+    // A stream frame containing stream type will be written on the control
+    // stream first.
+    std::string type(1, 0x00);
+
+    quic::SettingsFrame settings;
+    settings.values[quic::kSettingsMaxHeaderListSize] =
+        quic::kDefaultMaxUncompressedHeaderSize;
+    std::unique_ptr<char[]> buffer1;
+    quic::QuicByteCount frame_length1 =
+        http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+    std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+    quic::QuicStreamFrame type_frame;
+    quic::QuicStreamFrame settings_frame;
+    quic::QuicFrames frames;
+    if (stream_offsets_[2] == 0) {
+      type_frame = GenerateNextStreamFrame(2, false, type);
+      frames.push_back(quic::QuicFrame(type_frame));
+      settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+      frames.push_back(quic::QuicFrame(settings_frame));
+    }
+
+    quic::PriorityFrame frame;
+    frame.weight = priority;
+    frame.dependency_type = quic::ROOT_OF_TREE;
+    frame.prioritized_type = quic::REQUEST_STREAM;
+    frame.prioritized_element_id = stream_id;
+
+    std::unique_ptr<char[]> buffer;
+    quic::QuicByteCount frame_length =
+        http_encoder_.SerializePriorityFrame(frame, &buffer);
+    std::string priority_data = std::string(buffer.get(), frame_length);
+
+    quic::QuicStreamFrame priority_frame =
+        GenerateNextStreamFrame(2, false, priority_data);
+
     std::vector<std::string> data = QpackEncodeHeaders(
         stream_id, std::move(headers), spdy_headers_frame_length);
     std::vector<quic::QuicStreamFrame> stream_frames =
         GenerateNextStreamFrames(stream_id, fin, data);
 
-    quic::QuicFrames frames;
+    frames.push_back(quic::QuicFrame(priority_frame));
+
     for (const auto& frame : stream_frames)
       frames.push_back(quic::QuicFrame(frame));