1 // Copyright 2017 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <inttypes.h>
6
7 #include <memory>
8
9 #include "base/files/file_path.h"
10 #include "base/functional/bind.h"
11 #include "base/functional/callback.h"
12 #include "base/memory/ref_counted_memory.h"
13 #include "base/run_loop.h"
14 #include "base/strings/stringprintf.h"
15 #include "base/task/single_thread_task_runner.h"
16 #include "base/test/task_environment.h"
17 #include "base/time/time.h"
18 #include "net/base/load_timing_info.h"
19 #include "net/cert/mock_cert_verifier.h"
20 #include "net/dns/mapped_host_resolver.h"
21 #include "net/dns/mock_host_resolver.h"
22 #include "net/http/http_network_session.h"
23 #include "net/http/http_status_code.h"
24 #include "net/quic/crypto/proof_source_chromium.h"
25 #include "net/quic/crypto_test_utils_chromium.h"
26 #include "net/quic/quic_context.h"
27 #include "net/test/cert_test_util.h"
28 #include "net/test/embedded_test_server/embedded_test_server.h"
29 #include "net/test/embedded_test_server/http_response.h"
30 #include "net/test/gtest_util.h"
31 #include "net/test/test_data_directory.h"
32 #include "net/third_party/quiche/src/quiche/quic/tools/quic_memory_cache_backend.h"
33 #include "net/tools/quic/quic_simple_server.h"
34 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
35 #include "net/url_request/url_request.h"
36 #include "net/url_request/url_request_context.h"
37 #include "net/url_request/url_request_context_builder.h"
38 #include "net/url_request/url_request_test_util.h"
39 #include "testing/gmock/include/gmock/gmock.h"
40 #include "testing/gtest/include/gtest/gtest.h"
41 #include "testing/perf/perf_result_reporter.h"
42 #include "url/gurl.h"
43
44 using testing::_;
45 using testing::Invoke;
46 using testing::Contains;
47 using testing::Eq;
48 using testing::ByRef;
49
50 namespace net {
51
52 namespace {
53
54 constexpr int kAltSvcPort = 6121;
55 constexpr char kOriginHost[] = "mail.example.com";
56 constexpr char kAltSvcHost[] = "test.example.com";
57 // Used as a simple response from the server.
58 constexpr char kHelloPath[] = "/hello.txt";
59 constexpr char kHelloAltSvcResponse[] = "Hello from QUIC Server";
60 constexpr char kHelloOriginResponse[] = "Hello from TCP Server";
61 constexpr int kHelloStatus = 200;
62
63 constexpr char kMetricPrefixURLRequestQuick[] = "URLRequestQuic.";
64 constexpr char kMetricRequestTimeMs[] = "request_time";
65
SetUpURLRequestQuicReporter(const std::string & story)66 perf_test::PerfResultReporter SetUpURLRequestQuicReporter(
67 const std::string& story) {
68 perf_test::PerfResultReporter reporter(kMetricPrefixURLRequestQuick, story);
69 reporter.RegisterImportantMetric(kMetricRequestTimeMs, "ms");
70 return reporter;
71 }
72
HandleRequest(const test_server::HttpRequest & request)73 std::unique_ptr<test_server::HttpResponse> HandleRequest(
74 const test_server::HttpRequest& request) {
75 auto http_response = std::make_unique<test_server::BasicHttpResponse>();
76 std::string alpn =
77 quic::AlpnForVersion(DefaultSupportedQuicVersions().front());
78 http_response->AddCustomHeader(
79 "Alt-Svc", base::StringPrintf("%s=\"%s:%d\"", alpn.c_str(), kAltSvcHost,
80 kAltSvcPort));
81 http_response->set_code(HTTP_OK);
82 http_response->set_content(kHelloOriginResponse);
83 http_response->set_content_type("text/plain");
84 return std::move(http_response);
85 }
86
87 class URLRequestQuicPerfTest : public ::testing::Test {
88 protected:
URLRequestQuicPerfTest()89 URLRequestQuicPerfTest()
90 : task_environment_(
91 std::make_unique<base::test::SingleThreadTaskEnvironment>(
92 base::test::SingleThreadTaskEnvironment::MainThreadType::IO)),
93 cert_verifier_(std::make_unique<MockCertVerifier>()) {
94 StartTcpServer();
95 StartQuicServer();
96
97 // Host mapping.
98 auto resolver = std::make_unique<MockHostResolver>();
99 resolver->rules()->AddRule(kAltSvcHost, "127.0.0.1");
100 auto host_resolver =
101 std::make_unique<MappedHostResolver>(std::move(resolver));
102 std::string map_rule = base::StringPrintf("MAP %s 127.0.0.1:%d",
103 kOriginHost, tcp_server_->port());
104 EXPECT_TRUE(host_resolver->AddRuleFromString(map_rule));
105
106 HttpNetworkSessionParams params;
107 params.enable_quic = true;
108 params.enable_user_alternate_protocol_ports = true;
109 auto quic_context = std::make_unique<QuicContext>();
110 quic_context->params()->allow_remote_alt_svc = true;
111 auto context_builder = CreateTestURLRequestContextBuilder();
112 context_builder->set_host_resolver(std::move(host_resolver));
113 context_builder->set_http_network_session_params(params);
114 context_builder->SetCertVerifier(std::move(cert_verifier_));
115 context_builder->set_quic_context(std::move(quic_context));
116 context_ = context_builder->Build();
117 }
118
TearDown()119 void TearDown() override {
120 CHECK(quic_server_);
121 quic_server_->Shutdown();
122 // If possible, deliver the connection close packet to the client before
123 // destruct the URLRequestContext.
124 base::RunLoop().RunUntilIdle();
125 }
126
CreateRequest(const GURL & url,RequestPriority priority,URLRequest::Delegate * delegate)127 std::unique_ptr<URLRequest> CreateRequest(const GURL& url,
128 RequestPriority priority,
129 URLRequest::Delegate* delegate) {
130 return context_->CreateRequest(url, priority, delegate,
131 TRAFFIC_ANNOTATION_FOR_TESTS);
132 }
133
context() const134 URLRequestContext* context() const { return context_.get(); }
135
136 private:
StartQuicServer()137 void StartQuicServer() {
138 quic::QuicConfig config;
139 memory_cache_backend_.AddSimpleResponse(kOriginHost, kHelloPath,
140 kHelloStatus, kHelloAltSvcResponse);
141 quic_server_ = std::make_unique<QuicSimpleServer>(
142 net::test::ProofSourceForTestingChromium(), config,
143 quic::QuicCryptoServerConfig::ConfigOptions(),
144 quic::AllSupportedVersions(), &memory_cache_backend_);
145 int rv = quic_server_->Listen(
146 net::IPEndPoint(net::IPAddress::IPv4AllZeros(), kAltSvcPort));
147 ASSERT_GE(rv, 0) << "Quic server failed to start";
148
149 CertVerifyResult verify_result;
150 verify_result.verified_cert = ImportCertFromFile(
151 GetTestCertsDirectory(), "quic-chain.pem");
152 verify_result.is_issued_by_known_root = true;
153 cert_verifier().AddResultForCert(verify_result.verified_cert.get(),
154 verify_result, OK);
155 }
156
StartTcpServer()157 void StartTcpServer() {
158 tcp_server_ = std::make_unique<EmbeddedTestServer>(
159 net::EmbeddedTestServer::TYPE_HTTPS);
160 tcp_server_->RegisterRequestHandler(base::BindRepeating(&HandleRequest));
161 ASSERT_TRUE(tcp_server_->Start()) << "HTTP/1.1 server failed to start";
162
163 CertVerifyResult verify_result;
164 verify_result.verified_cert = tcp_server_->GetCertificate();
165 cert_verifier().AddResultForCert(tcp_server_->GetCertificate(),
166 verify_result, OK);
167 }
168
cert_verifier()169 MockCertVerifier& cert_verifier() {
170 // `cert_verifier_` becomes unset when it is passed to the
171 // URLRequestContext, but we need to be available earlier than then so that
172 // StartTcpServer() can call it. So look for it in both places.
173 return cert_verifier_ ? *cert_verifier_ :
174 // This cast is safe because we set a MockCertVerifier
175 // in the constructor.
176 *static_cast<MockCertVerifier*>(context_->cert_verifier());
177 }
178
179 std::unique_ptr<base::test::SingleThreadTaskEnvironment> task_environment_;
180 std::unique_ptr<EmbeddedTestServer> tcp_server_;
181 std::unique_ptr<QuicSimpleServer> quic_server_;
182 std::unique_ptr<URLRequestContext> context_;
183 std::unique_ptr<MockCertVerifier> cert_verifier_;
184 quic::QuicMemoryCacheBackend memory_cache_backend_;
185 };
186
187 } // namespace
188
TEST_F(URLRequestQuicPerfTest,TestGetRequest)189 TEST_F(URLRequestQuicPerfTest, TestGetRequest) {
190 bool quic_succeeded = false;
191 GURL url(base::StringPrintf("https://%s%s", kOriginHost, kHelloPath));
192 base::TimeTicks start = base::TimeTicks::Now();
193 constexpr int kNumRequest = 1000;
194 for (int i = 0; i < kNumRequest; ++i) {
195 TestDelegate delegate;
196 std::unique_ptr<URLRequest> request =
197 CreateRequest(url, DEFAULT_PRIORITY, &delegate);
198
199 request->Start();
200 EXPECT_TRUE(request->is_pending());
201 delegate.RunUntilComplete();
202
203 EXPECT_EQ(OK, delegate.request_status());
204 if (delegate.data_received() == kHelloAltSvcResponse) {
205 quic_succeeded = true;
206 } else {
207 EXPECT_EQ(kHelloOriginResponse, delegate.data_received());
208 }
209 }
210 base::TimeTicks end = base::TimeTicks::Now();
211 auto reporter = SetUpURLRequestQuicReporter("get");
212 reporter.AddResult(kMetricRequestTimeMs,
213 (end - start).InMillisecondsF() / kNumRequest);
214
215 EXPECT_TRUE(quic_succeeded);
216 }
217
218 } // namespace net
219