Adds QUIC_VERSION_36 which adds support to force HOL blocking between streams for measurement purpo…

net/quic/quic_session_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 "net/quic/quic_session.h"
 
 #include <set>
 #include <utility>
 
 #include "base/rand_util.h"
@@ skipping 14 matching lines @@
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::SpdyHeaderBlock;
+using net::SpdyPriority;
 using std::set;
 using std::string;
 using std::vector;
 using testing::CreateFunctor;
+using testing::AtLeast;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
@@ skipping 665 matching lines @@
   // Ensure that Writev consumes all the data it is given (simulate no socket
   // blocking).
   session_.set_writev_consumes_all_data(true);
 
   // Create a stream, and send enough data to make it flow control blocked.
   TestStream* stream2 = session_.CreateOutgoingDynamicStream(kDefaultPriority);
   string body(kMinimumFlowControlSendWindow, '.');
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
-  EXPECT_CALL(*connection_, SendBlocked(stream2->id()));
+  EXPECT_CALL(*connection_, SendBlocked(_)).Times(AtLeast(1));
   EXPECT_CALL(*connection_, SendBlocked(0));
   stream2->WriteOrBufferBody(body, false, nullptr);
   EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
   EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
   EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
   // The handshake message will call OnCanWrite, so the stream can resume
   // writing.
   EXPECT_CALL(*stream2, OnCanWrite());
   // Now complete the crypto handshake, resulting in an increased flow control
@@ skipping 376 matching lines @@
   // The max number of open outgoing streams is less than that of incoming
   // streams, and it should be same as negotiated value.
   EXPECT_LT(session_.max_open_outgoing_streams(),
             session_.max_open_incoming_streams());
   EXPECT_EQ(session_.max_open_outgoing_streams(),
             kDefaultMaxStreamsPerConnection);
   EXPECT_GT(session_.max_open_incoming_streams(),
             kDefaultMaxStreamsPerConnection);
 }
 
+TEST_P(QuicSessionTestServer, EnableFHOLThroughConfigOption) {
+  QuicConfigPeer::SetReceivedForceHolBlocking(session_.config());
+  session_.OnConfigNegotiated();
+  if (version() <= QUIC_VERSION_35) {
+    EXPECT_FALSE(session_.force_hol_blocking());
+  } else {
+    EXPECT_TRUE(session_.force_hol_blocking());
+  }
+}
+
 class QuicSessionTestClient : public QuicSessionTestBase {
  protected:
   QuicSessionTestClient() : QuicSessionTestBase(Perspective::IS_CLIENT) {}
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSessionTestClient,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSessionTestClient, AvailableStreamsClient) {
@@ skipping 57 matching lines @@
 
   QuicTagVector copt;
   copt.push_back(kDHDT);
   QuicConfigPeer::SetConnectionOptionsToSend(session_.config(), copt);
   session_.OnConfigNegotiated();
   EXPECT_EQ(QuicHeadersStreamPeer::GetSpdyFramer(session_.headers_stream())
                 .header_encoder_table_size(),
             0UL);
 }
 
+TEST_P(QuicSessionTestClient, EnableFHOLThroughConfigOption) {
+  session_.config()->SetForceHolBlocking();
+  session_.OnConfigNegotiated();
+  if (version() <= QUIC_VERSION_35) {
+    EXPECT_FALSE(session_.force_hol_blocking());
+  } else {
+    EXPECT_TRUE(session_.force_hol_blocking());
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net