Roll src/net/third_party/quiche/src/ 753002dae..7deaf37e9 (9 commits)

https://quiche.googlesource.com/quiche.git/+log/753002daef60..7deaf37e9442

$ git log 753002dae..7deaf37e9 --date=short --no-merges --format='%ad %ae %s'
2019-07-25 bnc Make QuicSpdyStreamBodyBuffer manage consuming HEADERS frame header and payload.
2019-07-25 renjietang Create HTTP/3 unidirectional stream only when stream limit allows.
2019-07-25 fayang gfe-relnote: In QUIC, replaces QuicStream::priority_ with QuicStream::precedence_ and pluming it to write_blocked_list. No functional change expected. Not protected.
2019-07-25 bnc Rewrite QuicSpdyStreamBodyBuffer's consumed byte tracking algorithm.
2019-07-25 bnc Add QpackHeaderTable::draining_index().
2019-07-25 bnc Use QpackEncodeRequiredInsertCount(0) instead of 0 in QpackEncoder.
2019-07-24 dschinazi Internal QUICHE change
2019-07-24 renjietang gfe-relnote: n/a - Remove unused member variable in QuicSpdySession
2019-07-24 nharper Add tool for testing quic interop

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

update flags


R=rch@chromium.org

Change-Id: Ic6c9b0ae4f4d4dadd928d771eb6b64ded55f497d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1721459Reviewed-by: Zhongyi Shi <zhongyi@chromium.org>
Commit-Queue: Dan Zhang <danzh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#682261}

DEPS

@@ -284,7 +284,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': '753002daef6045500f08066b132da7fd71ab4ca9',
+  'quiche_revision': '7deaf37e9442e433e4d90d11c940f59cdbb184cc',
   # 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/BUILD.gn

@@ -3248,6 +3248,18 @@ if (is_linux) {
       "//third_party/boringssl",
     ]
   }
+
+  executable("quic_client_for_interop_test") {
+    sources = [
+      "third_party/quiche/src/quic/tools/fake_proof_verifier.h",
+      "third_party/quiche/src/quic/tools/quic_client_interop_test_bin.cc",
+    ]
+    deps = [
+      ":epoll_quic_tools",
+      ":net",
+      ":simple_quic_tools",
+    ]
+  }
 }
 
 if (is_android) {

net/http/http_proxy_connect_job.cc

@@ -698,7 +698,8 @@ int HttpProxyConnectJob::DoQuicProxyCreateStreamComplete(int result) {
 
   spdy::SpdyPriority spdy_priority =
       ConvertRequestPriorityToQuicPriority(kH2QuicTunnelPriority);
-  quic_stream->SetPriority(spdy_priority);
+  spdy::SpdyStreamPrecedence precedence(spdy_priority);
+  quic_stream->SetPriority(precedence);
 
   transport_socket_ = std::make_unique<QuicProxyClientSocket>(
       std::move(quic_stream), std::move(quic_session_), GetUserAgent(),

net/quic/quic_chromium_client_session.cc

@@ -939,7 +939,7 @@ size_t QuicChromiumClientSession::WriteHeadersOnHeadersStream(
     quic::QuicStreamId id,
     spdy::SpdyHeaderBlock headers,
     bool fin,
-    spdy::SpdyPriority priority,
+    const spdy::SpdyStreamPrecedence& precedence,
     quic::QuicReferenceCountedPointer<quic::QuicAckListenerInterface>
         ack_listener) {
   spdy::SpdyStreamId parent_stream_id = 0;
@@ -947,10 +947,11 @@ size_t QuicChromiumClientSession::WriteHeadersOnHeadersStream(
   bool exclusive = false;
 
   if (headers_include_h2_stream_dependency_) {
-    priority_dependency_state_.OnStreamCreation(id, priority, &parent_stream_id,
-                                                &weight, &exclusive);
+    priority_dependency_state_.OnStreamCreation(id, precedence.spdy3_priority(),
+                                                &parent_stream_id, &weight,
+                                                &exclusive);
   } else {
-    weight = spdy::Spdy3PriorityToHttp2Weight(priority);
+    weight = spdy::Spdy3PriorityToHttp2Weight(precedence.spdy3_priority());
   }
 
   return WriteHeadersOnHeadersStreamImpl(id, std::move(headers), fin,
@@ -968,10 +969,11 @@ void QuicChromiumClientSession::UnregisterStreamPriority(quic::QuicStreamId id,
 
 void QuicChromiumClientSession::UpdateStreamPriority(
     quic::QuicStreamId id,
-    spdy::SpdyPriority new_priority) {
+    const spdy::SpdyStreamPrecedence& new_precedence) {
   if (headers_include_h2_stream_dependency_ ||
       VersionHasStreamType(connection()->transport_version())) {
-    auto updates = priority_dependency_state_.OnStreamUpdate(id, new_priority);
+    auto updates = priority_dependency_state_.OnStreamUpdate(
+        id, new_precedence.spdy3_priority());
     for (auto update : updates) {
       if (!VersionHasStreamType(connection()->transport_version())) {
         WritePriority(update.id, update.parent_stream_id, update.weight,
@@ -988,7 +990,7 @@ void QuicChromiumClientSession::UpdateStreamPriority(
       }
     }
   }
-  quic::QuicSpdySession::UpdateStreamPriority(id, new_priority);
+  quic::QuicSpdySession::UpdateStreamPriority(id, new_precedence);
 }
 
 void QuicChromiumClientSession::OnStreamFrame(

net/quic/quic_chromium_client_session.h

@@ -465,12 +465,13 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
       quic::QuicStreamId id,
       spdy::SpdyHeaderBlock headers,
       bool fin,
-      spdy::SpdyPriority priority,
+      const spdy::SpdyStreamPrecedence& precedence,
       quic::QuicReferenceCountedPointer<quic::QuicAckListenerInterface>
           ack_listener) override;
   void UnregisterStreamPriority(quic::QuicStreamId id, bool is_static) override;
-  void UpdateStreamPriority(quic::QuicStreamId id,
-                            spdy::SpdyPriority new_priority) override;
+  void UpdateStreamPriority(
+      quic::QuicStreamId id,
+      const spdy::SpdyStreamPrecedence& new_precedence) override;
 
   // quic::QuicSession methods:
   void OnStreamFrame(const quic::QuicStreamFrame& frame) override;
@@ -841,7 +842,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
   bool ignore_read_error_;
 
   // If true, client headers will include HTTP/2 stream dependency info derived
-  // from spdy::SpdyPriority.
+  // from spdy::SpdyStreamPrecedence.
   bool headers_include_h2_stream_dependency_;
   Http2PriorityDependencies priority_dependency_state_;
 

net/quic/quic_chromium_client_stream.cc

@@ -257,9 +257,9 @@ void QuicChromiumClientStream::Handle::
 }
 
 void QuicChromiumClientStream::Handle::SetPriority(
-    spdy::SpdyPriority priority) {
+    const spdy::SpdyStreamPrecedence& precedence) {
   if (stream_)
-    stream_->SetPriority(priority);
+    stream_->SetPriority(precedence);
 }
 
 void QuicChromiumClientStream::Handle::Reset(
@@ -542,8 +542,8 @@ size_t QuicChromiumClientStream::WriteHeaders(
   net_log_.AddEvent(
       NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
       [&](NetLogCaptureMode capture_mode) {
-        return QuicRequestNetLogParams(id(), &header_block, priority(),
-                                       capture_mode);
+        return QuicRequestNetLogParams(
+            id(), &header_block, precedence().spdy3_priority(), capture_mode);
       });
   size_t len = quic::QuicSpdyStream::WriteHeaders(std::move(header_block), fin,
                                                   std::move(ack_listener));

net/quic/quic_chromium_client_stream.h

@@ -107,8 +107,8 @@ class NET_EXPORT_PRIVATE QuicChromiumClientStream
     // stream is open.
     void DisableConnectionMigrationToCellularNetwork();
 
-    // Sets the priority of the stream to |priority|.
-    void SetPriority(spdy::SpdyPriority priority);
+    // Sets the precedence of the stream to |precedence|.
+    void SetPriority(const spdy::SpdyStreamPrecedence& precedence);
 
     // Sends a RST_STREAM frame to the peer and closes the streams.
     void Reset(quic::QuicRstStreamErrorCode error_code);

net/quic/quic_chromium_client_stream_test.cc

@@ -79,7 +79,8 @@ class MockQuicClientSessionBase : public quic::QuicSpdyClientSessionBase {
                void(quic::QuicStreamId stream_id,
                     quic::QuicStringPiece headers_data));
   MOCK_METHOD2(OnStreamHeadersPriority,
-               void(quic::QuicStreamId stream_id, spdy::SpdyPriority priority));
+               void(quic::QuicStreamId stream_id,
+                    const spdy::SpdyStreamPrecedence& precedence));
   MOCK_METHOD3(OnStreamHeadersComplete,
                void(quic::QuicStreamId stream_id, bool fin, size_t frame_len));
   MOCK_METHOD2(OnPromiseHeaders,
@@ -96,17 +97,17 @@ class MockQuicClientSessionBase : public quic::QuicSpdyClientSessionBase {
       quic::QuicStreamId id,
       spdy::SpdyHeaderBlock headers,
       bool fin,
-      spdy::SpdyPriority priority,
+      const spdy::SpdyStreamPrecedence& precedence,
       quic::QuicReferenceCountedPointer<quic::QuicAckListenerInterface>
           ack_listener) override {
-    return WriteHeadersOnHeadersStreamMock(id, headers, fin, priority,
+    return WriteHeadersOnHeadersStreamMock(id, headers, fin, precedence,
                                            std::move(ack_listener));
   }
   MOCK_METHOD5(WriteHeadersOnHeadersStreamMock,
                size_t(quic::QuicStreamId id,
                       const spdy::SpdyHeaderBlock& headers,
                       bool fin,
-                      spdy::SpdyPriority priority,
+                      const spdy::SpdyStreamPrecedence& precedence,
                       const quic::QuicReferenceCountedPointer<
                           quic::QuicAckListenerInterface>& ack_listener));
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(quic::QuicTime::Delta delta));

net/quic/quic_flags_list.h

@@ -339,4 +339,4 @@ QUIC_FLAG(bool,
 QUIC_FLAG(
     bool,
     FLAGS_quic_restart_flag_quic_dispatcher_hands_chlo_extractor_one_version,
-    true)
+    false)

net/quic/quic_http_stream.cc

@@ -182,7 +182,8 @@ int QuicHttpStream::DoHandlePromiseComplete(int rv) {
 
   spdy::SpdyPriority spdy_priority =
       ConvertRequestPriorityToQuicPriority(priority_);
-  stream_->SetPriority(spdy_priority);
+  const spdy::SpdyStreamPrecedence precedence(spdy_priority);
+  stream_->SetPriority(precedence);
 
   next_state_ = STATE_OPEN;
   NetLogQuicPushStream(stream_net_log_, quic_session()->net_log(),
@@ -572,7 +573,8 @@ int QuicHttpStream::DoSetRequestPriority() {
   DCHECK(response_info_);
 
   spdy::SpdyPriority priority = ConvertRequestPriorityToQuicPriority(priority_);
-  stream_->SetPriority(priority);
+  spdy::SpdyStreamPrecedence precedence(priority);
+  stream_->SetPriority(precedence);
   next_state_ = STATE_SEND_HEADERS;
   return OK;
 }

net/quic/quic_http_utils.h

@@ -15,6 +15,8 @@
 
 namespace net {
 
+// TODO(crbug/988608): Convert to SpdyStreamPrecedence directly instead of to
+// SpdyPriority which will go away eventually.
 NET_EXPORT_PRIVATE spdy::SpdyPriority ConvertRequestPriorityToQuicPriority(
     RequestPriority priority);