Notfiy NQE of QUIC RTT

net/quic/quic_network_transaction_unittest.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 <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
+#include "net/base/network_quality_estimator.h"
+#include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/http/http_stream_factory.h"
@@ skipping 111 matching lines @@
 
   void OnBeforeProxyHeadersSent(const ProxyInfo& proxy_info,
                                 HttpRequestHeaders* request_headers) {
     was_called_ = true;
   }
 
  private:
   bool was_called_;
 };
 
+// Verifies whether the socket performance watcher was notified of updated RTT.
+class WatcherNotificationVerifier {
+ public:
+  WatcherNotificationVerifier()
+      : received_updated_rtt_available_notification_(false) {}
+
+  virtual ~WatcherNotificationVerifier() {}
+
+  void OnUpdatedRTTAvailable() {
+    received_updated_rtt_available_notification_ = true;
+  }
+
+  bool IsRTTAvailableRTTNotificationReceived() const {
+    return received_updated_rtt_available_notification_;
+  }
+
+ private:
+  bool received_updated_rtt_available_notification_;
+  DISALLOW_COPY_AND_ASSIGN(WatcherNotificationVerifier);
+};

[Ryan Hamilton, 2015/09/18 15:56:38]

Instead of creating this class which exists simply to outlive the actual
PerformanceWatcher an alternative would be to EXPECT_TRUE(have_rtt_update_) in
the TestWatcher destructor. I think that would avoid some extra code.

[tbansal1, 2015/09/18 17:21:20]

Removed the class. I am not sure if EXPECT_TRUE(have_rtt_update_) is the right
approach. In some tests, RTT update is not received, and that is verified.

+
+class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
+ public:
+  TestSocketPerformanceWatcher(WatcherNotificationVerifier* watcher_checker)
+      : watcher_notification_verifier_(watcher_checker) {}
+
+  ~TestSocketPerformanceWatcher() override {}
+
+  void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) override {
+    watcher_notification_verifier_->OnUpdatedRTTAvailable();
+  }
+
+ private:
+  WatcherNotificationVerifier* watcher_notification_verifier_;
+  DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher);
+};
+
+class TestNetworkQualityEstimator : public NetworkQualityEstimator {

[Ryan Hamilton, 2015/09/18 15:56:38]

Instead of a full blown NQE, how 'bout just a  SocketPerformanceWatcherFactory
since that's all you need?

[tbansal1, 2015/09/18 17:21:20]

Yeah, I had TestSocketPerformanceWatcherFactory before, but thought it might be
better to test with NQE because that's the one implementing. It seems like a
more realistic test. wdyt?

[Ryan Hamilton, 2015/09/18 22:01:26]

Are you actually testing any methods of the NQE beyond those used in this test?

[tbansal1, 2015/09/18 22:36:22]

Not right now. That's because NQE is not doing anything with the RTT data. Once
https://codereview.chromium.org/1273173002/ lands, it will start notifying
observers. Then, I can add an observer, and see if it gets notified or not.

For now, if you think it is better to use SocketPerformanceWatcherFactory, I can
do that. Later, I can change it to use TestNQE, once NQE starts doing something
with the data.

+ public:
+  TestNetworkQualityEstimator()
+      : NetworkQualityEstimator(scoped_ptr<net::ExternalEstimateProvider>(),
+                                std::map<std::string, std::string>()),
+        watcher_notification_verifier_(new WatcherNotificationVerifier()),
+        watchers_created_(0) {}
+
+  ~TestNetworkQualityEstimator() override {}
+
+  scoped_ptr<SocketPerformanceWatcher> CreateUDPSocketPerformanceWatcher()
+      const override {
+    watchers_created_++;
+    return scoped_ptr<TestSocketPerformanceWatcher>(
+        new TestSocketPerformanceWatcher(watcher_notification_verifier_.get()));
+  }
+
+  scoped_ptr<SocketPerformanceWatcher> CreateTCPSocketPerformanceWatcher()
+      const override {
+    NOTIMPLEMENTED();
+    return scoped_ptr<SocketPerformanceWatcher>();
+  }
+
+  bool IsRTTAvailableRTTNotificationReceived() const {
+    return watcher_notification_verifier_
+        ->IsRTTAvailableRTTNotificationReceived();
+  }
+
+  size_t GetWatchersCreated() const { return watchers_created_; }
+
+ private:
+  scoped_ptr<WatcherNotificationVerifier> watcher_notification_verifier_;
+  mutable size_t watchers_created_;
+  DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
+};
+
 class QuicNetworkTransactionTest
     : public PlatformTest,
       public ::testing::WithParamInterface<QuicVersion> {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
         maker_(GetParam(), 0, clock_, kDefaultServerHostName),
+        test_network_quality_estimator_(new TestNetworkQualityEstimator()),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
         random_generator_(0),
         hanging_data_(nullptr, 0, nullptr, 0) {
     request_.method = "GET";
     std::string url("http://");
     url.append(kDefaultServerHostName);
     request_.url = GURL(url);
@@ skipping 82 matching lines @@
   void CreateSessionWithFactory(ClientSocketFactory* socket_factory,
                                 bool use_next_protos) {
     params_.enable_quic = true;
     params_.quic_clock = clock_;
     params_.quic_random = &random_generator_;
     params_.client_socket_factory = socket_factory;
     params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
     params_.host_resolver = &host_resolver_;
     params_.cert_verifier = &cert_verifier_;
     params_.transport_security_state = &transport_security_state_;
+    params_.socket_performance_watcher_factory =
+        test_network_quality_estimator_.get();
     params_.proxy_service = proxy_service_.get();
     params_.ssl_config_service = ssl_config_service_.get();
     params_.http_auth_handler_factory = auth_handler_factory_.get();
     params_.http_server_properties = http_server_properties_.GetWeakPtr();
     params_.quic_supported_versions = SupportedVersions(GetParam());
 
     if (use_next_protos) {
       params_.use_alternative_services = true;
       params_.next_protos = NextProtosWithSpdyAndQuic(true, true);
     }
@@ skipping 104 matching lines @@
   }
 
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   QuicTestPacketMaker maker_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
+  scoped_ptr<TestNetworkQualityEstimator> test_network_quality_estimator_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   MockRandom random_generator_;
   HttpServerPropertiesImpl http_server_properties_;
   HttpNetworkSession::Params params_;
   HttpRequestInfo request_;
   BoundTestNetLog net_log_;
   StaticSocketDataProvider hanging_data_;
 
@@ skipping 38 matching lines @@
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   SendRequestAndExpectQuicResponse("hello!");
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());
 
   // Check that the NetLog was filled reasonably.
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged a QUIC_SESSION_PACKET_RECEIVED.
   int pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
       NetLog::PHASE_NONE);
@@ skipping 40 matching lines @@
       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
                                      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   // There is no need to set up an alternate protocol job, because
   // no attempt will be made to speak to the proxy over TCP.
 
   CreateSession();
 
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 // Regression test for https://crbug.com/492458.  Test that for an HTTP
 // connection through a QUIC proxy, the certificate exhibited by the proxy is
 // checked against the proxy hostname, not the origin hostname.
 TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) {
   const std::string origin_host = "news.example.com";
   const std::string proxy_host = "www.example.org";
 
   params_.enable_insecure_quic = true;
@@ skipping 23 matching lines @@
   EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, &common_name_fallback_used));
   EXPECT_FALSE(cert->VerifyNameMatch(origin_host, &common_name_fallback_used));
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   request_.url = GURL("http://" + origin_host);
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
   params_.enable_insecure_quic = true;
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:80");
 
-  MockQuicData mock_quic_data;
-  mock_quic_data.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
+  MockQuicData mock_quic_data1;
+  mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
 
-  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
+  MockQuicData mock_quic_data2;
+  mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
+
+  mock_quic_data1.AddSocketDataToFactory(&socket_factory_);
+  mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
-  scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
-  TestCompletionCallback callback;
-  int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
+  for (size_t i = 0; i < 2; ++i) {
+    scoped_ptr<HttpNetworkTransaction> trans(
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
+    TestCompletionCallback callback;
+    int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
+    EXPECT_EQ(1 + i, test_network_quality_estimator_->GetWatchersCreated());
+  }
 }
 
 TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
   // Attempt to "force" quic on 443, which will not be honored.
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:443");
 
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider data(http_reads, arraysize(http_reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuic) {
   params_.enable_insecure_quic = true;
 
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead(kQuicAlternativeServiceHttpHeader), MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
@@ skipping 856 matching lines @@
   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
       QuicSession::HANDSHAKE_CONFIRMED);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   CheckWasQuicResponse(trans);
   CheckResponseData(trans, "hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
   params_.enable_insecure_quic = true;
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   // Alternate-protocol job
   scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
   MockRead quic_reads[] = {
       MockRead(ASYNC, close->data(), close->length()),
       MockRead(ASYNC, ERR_IO_PENDING),  // No more data to read
       MockRead(ASYNC, OK),              // EOF
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) {
   params_.enable_insecure_quic = true;
   // Alternate-protocol job
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSessionWithNextProtos();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) {
   params_.enable_insecure_quic = true;
   // Alternate-protocol job will fail when the session attempts to read.
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      nullptr, 0);
@@ skipping 109 matching lines @@
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
 
   ExpectBrokenAlternateProtocolMapping();
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
 }
 
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
   params_.enable_insecure_quic = true;
   MockQuicData mock_quic_data;
   mock_quic_data.AddSynchronousRead(ConstructConnectionClosePacket(1));
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ skipping 57 matching lines @@
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC,
             callback.GetResult(rv));
 }
 
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
   params_.enable_insecure_quic = true;
   maker_.set_hostname("www.example.org");
+  EXPECT_FALSE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(0U, test_network_quality_estimator_->GetWatchersCreated());
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more read data.
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
   ASSERT_TRUE(cert.get());
   bool common_name_fallback_used;
   EXPECT_TRUE(
       cert->VerifyNameMatch("www.example.org", &common_name_fallback_used));
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
+  EXPECT_TRUE(
+      test_network_quality_estimator_->IsRTTAvailableRTTNotificationReceived());
+  EXPECT_EQ(1U, test_network_quality_estimator_->GetWatchersCreated());

[Ryan Hamilton, 2015/09/18 15:56:38]

I doesn't seem like we need to test this behavior in every test. That just makes
the tests harder to read. In any case, you could move this code into
SendRequestAndExpectQuicResponse, I suspect.

[tbansal1, 2015/09/18 17:21:20]

Agreed. Removed some of the tests.
Fails some tests e.g., SendRequestAndExpectHttpResponse which actually uses
non-QUIC connection.

 }
 
 }  // namespace test
 }  // namespace net