Add connection option kSMHL indicating supporting SETTINGS_MAX_HEADER_LIST_SIZE. SETTINGS_MAX_HEADE…

net/tools/quic/end_to_end_test.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <sys/epoll.h>
 
 #include <cstdint>
 #include <list>
 #include <memory>
@@ skipping 1799 matching lines @@
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   server_thread_->Pause();
   QuicSpdySession* const client_session = client_->client()->session();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   auto server_session = static_cast<QuicSpdySession*>(
       dispatcher->session_map().begin()->second.get());
-
   ExpectFlowControlsSynced(client_session->flow_controller(),
                            server_session->flow_controller());
   ExpectFlowControlsSynced(
       QuicSessionPeer::GetCryptoStream(client_session)->flow_controller(),
       QuicSessionPeer::GetCryptoStream(server_session)->flow_controller());
-  ExpectFlowControlsSynced(
-      QuicSpdySessionPeer::GetHeadersStream(client_session)->flow_controller(),
-      QuicSpdySessionPeer::GetHeadersStream(server_session)->flow_controller());
+  SpdyFramer spdy_framer(HTTP2);
+  SpdySettingsIR settings_frame;
+  settings_frame.AddSetting(SETTINGS_MAX_HEADER_LIST_SIZE, false, false,
+                            kDefaultMaxUncompressedHeaderSize);
+  SpdySerializedFrame frame(spdy_framer.SerializeFrame(settings_frame));
+  QuicFlowController* client_header_stream_flow_controller =
+      QuicSpdySessionPeer::GetHeadersStream(client_session)->flow_controller();
+  QuicFlowController* server_header_stream_flow_controller =
+      QuicSpdySessionPeer::GetHeadersStream(server_session)->flow_controller();
+  if (FLAGS_quic_send_max_header_list_size) {
+    // Both client and server are sending this SETTINGS frame, and the send
+    // window is consumed. But because of timing issue, the server may send or
+    // not send the frame, and the client may send/ not send / receive / not
+    // receive the frame.
+    // TODO(fayang): Rewrite this part because it is hacky.
+    QuicByteCount win_difference1 = QuicFlowControllerPeer::ReceiveWindowSize(
+                                        server_header_stream_flow_controller) -
+                                    QuicFlowControllerPeer::SendWindowSize(
+                                        client_header_stream_flow_controller);
+    QuicByteCount win_difference2 = QuicFlowControllerPeer::ReceiveWindowSize(
+                                        client_header_stream_flow_controller) -
+                                    QuicFlowControllerPeer::SendWindowSize(
+                                        server_header_stream_flow_controller);
+    EXPECT_TRUE(win_difference1 == 0 || win_difference1 == frame.size());
+    EXPECT_TRUE(win_difference2 == 0 || win_difference2 == frame.size());
+  } else {
+    ExpectFlowControlsSynced(
+        QuicSpdySessionPeer::GetHeadersStream(client_session)
+            ->flow_controller(),
+        QuicSpdySessionPeer::GetHeadersStream(server_session)
+            ->flow_controller());
+  }
 
   if (!client_session->force_hol_blocking()) {
-    EXPECT_EQ(static_cast<float>(QuicFlowControllerPeer::ReceiveWindowSize(
-                  client_session->flow_controller())) /
-                  QuicFlowControllerPeer::ReceiveWindowSize(
-                      QuicSpdySessionPeer::GetHeadersStream(client_session)
-                          ->flow_controller()),
-              kSessionToStreamRatio);
+    if (FLAGS_quic_send_max_header_list_size) {
+      // Client *may* have received the SETTINGs frame.
+      // TODO(fayang): Rewrite this part because it is hacky.
+      float ratio1 =
+          static_cast<float>(QuicFlowControllerPeer::ReceiveWindowSize(
+              client_session->flow_controller())) /
+          QuicFlowControllerPeer::ReceiveWindowSize(
+              QuicSpdySessionPeer::GetHeadersStream(client_session)
+                  ->flow_controller());
+      float ratio2 =
+          static_cast<float>(QuicFlowControllerPeer::ReceiveWindowSize(
+              client_session->flow_controller())) /
+          (QuicFlowControllerPeer::ReceiveWindowSize(
+               QuicSpdySessionPeer::GetHeadersStream(client_session)
+                   ->flow_controller()) +
+           frame.size());
+      EXPECT_TRUE(ratio1 == kSessionToStreamRatio ||
+                  ratio2 == kSessionToStreamRatio);
+    } else {
+      EXPECT_EQ(static_cast<float>(QuicFlowControllerPeer::ReceiveWindowSize(
+                    client_session->flow_controller())) /
+                    QuicFlowControllerPeer::ReceiveWindowSize(
+                        QuicSpdySessionPeer::GetHeadersStream(client_session)
+                            ->flow_controller()),
+                kSessionToStreamRatio);
+    }
   }
 
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, RequestWithNoBodyWillNeverSendStreamFrameWithFIN) {
   // A stream created on receipt of a simple request with no body will never get
   // a stream frame with a FIN. Verify that we don't keep track of the stream in
   // the locally closed streams map: it will never be removed if so.
   ASSERT_TRUE(Initialize());
@@ skipping 1143 matching lines @@
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net