BASELINE: Update Chromium to 67.0.3396.47

Change-Id: Idcb1341782e417561a2473eeecc82642dafda5b7
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

7 files changed, 355 insertions, 62 deletions

diff --git a/chromium/net/test/embedded_test_server/controllable_http_response.cc b/chromium/net/test/embedded_test_server/controllable_http_response.cc
index 2d13d54527f..226b126d6f5 100644
--- a/chromium/net/test/embedded_test_server/controllable_http_response.cc
+++ b/chromium/net/test/embedded_test_server/controllable_http_response.cc
@@ -15,9 +15,11 @@ class ControllableHttpResponse::Interceptor : public HttpResponse {
  public:
   explicit Interceptor(
       base::WeakPtr<ControllableHttpResponse> controller,
-      scoped_refptr<base::SingleThreadTaskRunner> controller_task_runner)
+      scoped_refptr<base::SingleThreadTaskRunner> controller_task_runner,
+      const HttpRequest& http_request)
       : controller_(controller),
-        controller_task_runner_(controller_task_runner) {}
+        controller_task_runner_(controller_task_runner),
+        http_request_(std::make_unique<HttpRequest>(http_request)) {}
   ~Interceptor() override {}
 
  private:
@@ -26,24 +28,28 @@ class ControllableHttpResponse::Interceptor : public HttpResponse {
     controller_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&ControllableHttpResponse::OnRequest, controller_,
-                       base::ThreadTaskRunnerHandle::Get(), send, done));
+                       base::ThreadTaskRunnerHandle::Get(), send, done,
+                       std::move(http_request_)));
   }
 
   base::WeakPtr<ControllableHttpResponse> controller_;
   scoped_refptr<base::SingleThreadTaskRunner> controller_task_runner_;
 
+  std::unique_ptr<HttpRequest> http_request_;
+
   DISALLOW_COPY_AND_ASSIGN(Interceptor);
 };
 
 ControllableHttpResponse::ControllableHttpResponse(
     EmbeddedTestServer* embedded_test_server,
-    const std::string& relative_url)
+    const std::string& relative_url,
+    bool relative_url_is_prefix)
     : weak_ptr_factory_(this) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  embedded_test_server->RegisterRequestHandler(
-      base::BindRepeating(RequestHandler, weak_ptr_factory_.GetWeakPtr(),
-                          base::ThreadTaskRunnerHandle::Get(),
-                          base::Owned(new bool(true)), relative_url));
+  embedded_test_server->RegisterRequestHandler(base::BindRepeating(
+      RequestHandler, weak_ptr_factory_.GetWeakPtr(),
+      base::ThreadTaskRunnerHandle::Get(), base::Owned(new bool(true)),
+      relative_url, relative_url_is_prefix));
 }
 
 ControllableHttpResponse::~ControllableHttpResponse() {}
@@ -83,13 +89,15 @@ void ControllableHttpResponse::OnRequest(
     scoped_refptr<base::SingleThreadTaskRunner>
         embedded_test_server_task_runner,
     const SendBytesCallback& send,
-    const SendCompleteCallback& done) {
+    const SendCompleteCallback& done,
+    std::unique_ptr<HttpRequest> http_request) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!embedded_test_server_task_runner_)
       << "A ControllableHttpResponse can only handle one request at a time";
   embedded_test_server_task_runner_ = embedded_test_server_task_runner;
   send_ = send;
   done_ = done;
+  http_request_ = std::move(http_request);
   loop_.Quit();
 }
 
@@ -100,12 +108,20 @@ std::unique_ptr<HttpResponse> ControllableHttpResponse::RequestHandler(
     scoped_refptr<base::SingleThreadTaskRunner> controller_task_runner,
     bool* available,
     const std::string& relative_url,
+    bool relative_url_is_prefix,
     const HttpRequest& request) {
-  if (*available && request.relative_url == relative_url) {
+  if (!*available)
+    return nullptr;
+
+  if (request.relative_url == relative_url ||
+      (relative_url_is_prefix &&
+       base::StartsWith(request.relative_url, relative_url,
+                        base::CompareCase::SENSITIVE))) {
     *available = false;
     return std::make_unique<ControllableHttpResponse::Interceptor>(
-        controller, controller_task_runner);
+        controller, controller_task_runner, request);
   }
+
   return nullptr;
 }
 
diff --git a/chromium/net/test/embedded_test_server/controllable_http_response.h b/chromium/net/test/embedded_test_server/controllable_http_response.h
index 74f7965926a..ffc72717e3f 100644
--- a/chromium/net/test/embedded_test_server/controllable_http_response.h
+++ b/chromium/net/test/embedded_test_server/controllable_http_response.h
@@ -27,10 +27,15 @@ namespace test_server {
 // handle only **one** request with the matching |relative_url|. In the case of
 // multiple ControllableHttpResponses for the same path, they're used in the
 // order they were created.
+//
+// If |relative_url_is_prefix| is true, |relative_url| is only compared agaisnt
+// the start of the URL being requested, which allows matching against (possibly
+// variable) query strings, for instance.
 class ControllableHttpResponse {
  public:
   ControllableHttpResponse(EmbeddedTestServer* embedded_test_server,
-                           const std::string& relative_path);
+                           const std::string& relative_url,
+                           bool relative_url_is_prefix = false);
   ~ControllableHttpResponse();
 
   // These method are intented to be used in order.
@@ -44,6 +49,9 @@ class ControllableHttpResponse {
   // 3) Notify there are no more data to be sent and close the socket.
   void Done();
 
+  // Returns the HttpRequest after a call to WaitForRequest.
+  const HttpRequest* http_request() const { return http_request_.get(); }
+
  private:
   class Interceptor;
 
@@ -52,13 +60,15 @@ class ControllableHttpResponse {
   void OnRequest(scoped_refptr<base::SingleThreadTaskRunner>
                      embedded_test_server_task_runner,
                  const SendBytesCallback& send,
-                 const SendCompleteCallback& done);
+                 const SendCompleteCallback& done,
+                 std::unique_ptr<HttpRequest> http_request);
 
   static std::unique_ptr<HttpResponse> RequestHandler(
       base::WeakPtr<ControllableHttpResponse> controller,
       scoped_refptr<base::SingleThreadTaskRunner> controller_task_runner,
       bool* available,
       const std::string& relative_url,
+      bool relative_url_is_prefix,
       const HttpRequest& request);
 
   State state_ = State::WAITING_FOR_REQUEST;
@@ -66,6 +76,8 @@ class ControllableHttpResponse {
   scoped_refptr<base::SingleThreadTaskRunner> embedded_test_server_task_runner_;
   SendBytesCallback send_;
   SendCompleteCallback done_;
+  std::unique_ptr<HttpRequest> http_request_;
+
   SEQUENCE_CHECKER(sequence_checker_);
 
   base::WeakPtrFactory<ControllableHttpResponse> weak_ptr_factory_;
diff --git a/chromium/net/test/embedded_test_server/default_handlers.cc b/chromium/net/test/embedded_test_server/default_handlers.cc
index bc89ab822e2..6d7375dede2 100644
--- a/chromium/net/test/embedded_test_server/default_handlers.cc
+++ b/chromium/net/test/embedded_test_server/default_handlers.cc
@@ -232,7 +232,7 @@ std::unique_ptr<HttpResponse> HandleExpectAndSetCookie(
   if (request.headers.find("Cookie") != request.headers.end()) {
     received_cookies =
         base::SplitString(request.headers.at("Cookie"), ";",
-                          base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   }
 
   bool got_all_expected = true;
diff --git a/chromium/net/test/embedded_test_server/embedded_test_server_unittest.cc b/chromium/net/test/embedded_test_server/embedded_test_server_unittest.cc
index 21c37e2205b..d6f74a11c10 100644
--- a/chromium/net/test/embedded_test_server/embedded_test_server_unittest.cc
+++ b/chromium/net/test/embedded_test_server/embedded_test_server_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
+#include <tuple>
 #include <utility>
 
 #include "base/macros.h"
@@ -16,7 +17,6 @@
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "crypto/nss_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/log/net_log_source.h"
@@ -36,10 +36,6 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(USE_NSS_CERTS)
-#include "net/cert_net/nss_ocsp.h"
-#endif
-
 using net::test::IsOk;
 
 namespace net {
@@ -130,15 +126,6 @@ class EmbeddedTestServerTest
   }
 
   void SetUp() override {
-#if defined(USE_NSS_CERTS)
-    // This is needed so NSS's HTTP client functions are initialized on the
-    // right thread. These tests create SSLClientSockets on a different thread.
-    // TODO(davidben): Initialization can't be deferred to SSLClientSocket. See
-    // https://crbug.com/539520.
-    crypto::EnsureNSSInit();
-    EnsureNSSHttpIOInit();
-#endif
-
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread_.StartWithOptions(thread_options));
@@ -153,9 +140,6 @@ class EmbeddedTestServerTest
   void TearDown() override {
     if (server_->Started())
       ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete());
-#if defined(USE_NSS_CERTS)
-    ShutdownNSSHttpIO();
-#endif
   }
 
   // URLFetcherDelegate override.
@@ -512,28 +496,10 @@ INSTANTIATE_TEST_CASE_P(EmbeddedTestServerTestInstantiation,
 // where there is no MessageLoop available on the thread at EmbeddedTestServer
 // initialization and/or destruction.
 
-typedef std::tr1::tuple<bool, bool, EmbeddedTestServer::Type>
-    ThreadingTestParams;
+typedef std::tuple<bool, bool, EmbeddedTestServer::Type> ThreadingTestParams;
 
 class EmbeddedTestServerThreadingTest
-    : public testing::TestWithParam<ThreadingTestParams> {
-  void SetUp() override {
-#if defined(USE_NSS_CERTS)
-    // This is needed so NSS's HTTP client functions are initialized on the
-    // right thread. These tests create SSLClientSockets on a different thread.
-    // TODO(davidben): Initialization can't be deferred to SSLClientSocket. See
-    // https://crbug.com/539520.
-    crypto::EnsureNSSInit();
-    EnsureNSSHttpIOInit();
-#endif
-  }
-
-  void TearDown() override {
-#if defined(USE_NSS_CERTS)
-    ShutdownNSSHttpIO();
-#endif
-  }
-};
+    : public testing::TestWithParam<ThreadingTestParams> {};
 
 class EmbeddedTestServerThreadingTestDelegate
     : public base::PlatformThread::Delegate,
@@ -604,9 +570,9 @@ TEST_P(EmbeddedTestServerThreadingTest, RunTest) {
   // of a MessageLoop - the test suite already sets up a MessageLoop for the
   // main test thread.
   base::PlatformThreadHandle thread_handle;
-  EmbeddedTestServerThreadingTestDelegate delegate(
-      std::tr1::get<0>(GetParam()), std::tr1::get<1>(GetParam()),
-      std::tr1::get<2>(GetParam()));
+  EmbeddedTestServerThreadingTestDelegate delegate(std::get<0>(GetParam()),
+                                                   std::get<1>(GetParam()),
+                                                   std::get<2>(GetParam()));
   ASSERT_TRUE(base::PlatformThread::Create(0, &delegate, &thread_handle));
   base::PlatformThread::Join(thread_handle);
 }
diff --git a/chromium/net/test/net_test_suite.cc b/chromium/net/test/net_test_suite.cc
index 792eeab126f..d26e50e4326 100644
--- a/chromium/net/test/net_test_suite.cc
+++ b/chromium/net/test/net_test_suite.cc
@@ -10,10 +10,6 @@
 #include "net/spdy/chromium/spdy_session.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(USE_NSS_CERTS)
-#include "net/cert_net/nss_ocsp.h"
-#endif
-
 namespace {
 base::test::ScopedTaskEnvironment::MainThreadType kDefaultMainThreadType =
     base::test::ScopedTaskEnvironment::MainThreadType::IO;
@@ -38,10 +34,6 @@ void NetTestSuite::Initialize() {
 }
 
 void NetTestSuite::Shutdown() {
-#if defined(USE_NSS_CERTS)
-  net::ShutdownNSSHttpIO();
-#endif
-
   // We want to destroy this here before the TestSuite continues to tear down
   // the environment.
   scoped_task_environment_.reset();
diff --git a/chromium/net/test/quic_simple_test_server.cc b/chromium/net/test/quic_simple_test_server.cc
new file mode 100644
index 00000000000..0f11650274e
--- /dev/null
+++ b/chromium/net/test/quic_simple_test_server.cc
@@ -0,0 +1,247 @@
+// Copyright 2016 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/test/quic_simple_test_server.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "net/base/ip_address.h"
+#include "net/base/ip_endpoint.h"
+#include "net/quic/chromium/crypto/proof_source_chromium.h"
+#include "net/spdy/core/spdy_header_block.h"
+#include "net/test/test_data_directory.h"
+#include "net/tools/quic/quic_dispatcher.h"
+#include "net/tools/quic/quic_http_response_cache.h"
+#include "net/tools/quic/quic_simple_server.h"
+
+namespace {
+
+const char kTestServerDomain[] = "example.com";
+// This must match the certificate used (quic-chain.pem and quic-leaf-cert.key).
+const char kTestServerHost[] = "test.example.com";
+
+const char kStatusHeader[] = ":status";
+
+const char kHelloPath[] = "/hello.txt";
+const char kHelloBodyValue[] = "Hello from QUIC Server";
+const char kHelloStatus[] = "200";
+
+const char kHelloHeaderName[] = "hello_header";
+const char kHelloHeaderValue[] = "hello header value";
+
+const char kHelloTrailerName[] = "hello_trailer";
+const char kHelloTrailerValue[] = "hello trailer value";
+
+const char kSimplePath[] = "/simple.txt";
+const char kSimpleBodyValue[] = "Simple Hello from QUIC Server";
+const char kSimpleStatus[] = "200";
+
+const char kSimpleHeaderName[] = "hello_header";
+const char kSimpleHeaderValue[] = "hello header value";
+
+base::Thread* g_quic_server_thread = nullptr;
+net::QuicHttpResponseCache* g_quic_response_cache = nullptr;
+net::QuicSimpleServer* g_quic_server = nullptr;
+int g_quic_server_port = 0;
+
+}  // namespace
+
+namespace net {
+
+const std::string QuicSimpleTestServer::GetDomain() {
+  return kTestServerDomain;
+}
+
+const std::string QuicSimpleTestServer::GetHost() {
+  return kTestServerHost;
+}
+
+GURL QuicSimpleTestServer::GetFileURL(const std::string& file_path) {
+  return GURL("https://test.example.com:" + base::NumberToString(GetPort()))
+      .Resolve(file_path);
+}
+
+GURL QuicSimpleTestServer::GetHelloURL() {
+  // Don't include |port| into Hello URL as it is mapped differently.
+  return GURL("https://test.example.com").Resolve(kHelloPath);
+}
+
+const std::string QuicSimpleTestServer::GetStatusHeaderName() {
+  return kStatusHeader;
+}
+
+// Hello Url returns response with HTTP/2 headers and trailers.
+const std::string QuicSimpleTestServer::GetHelloPath() {
+  return kHelloPath;
+}
+
+const std::string QuicSimpleTestServer::GetHelloBodyValue() {
+  return kHelloBodyValue;
+}
+const std::string QuicSimpleTestServer::GetHelloStatus() {
+  return kHelloStatus;
+}
+
+const std::string QuicSimpleTestServer::GetHelloHeaderName() {
+  return kHelloHeaderName;
+}
+
+const std::string QuicSimpleTestServer::GetHelloHeaderValue() {
+  return kHelloHeaderValue;
+}
+
+const std::string QuicSimpleTestServer::GetHelloTrailerName() {
+  return kHelloTrailerName;
+}
+
+const std::string QuicSimpleTestServer::GetHelloTrailerValue() {
+  return kHelloTrailerValue;
+}
+
+// Simple Url returns response without HTTP/2 trailers.
+GURL QuicSimpleTestServer::GetSimpleURL() {
+  // Don't include |port| into Simple URL as it is mapped differently.
+  return GURL("https://test.example.com").Resolve(kSimplePath);
+}
+
+const std::string QuicSimpleTestServer::GetSimpleBodyValue() {
+  return kSimpleBodyValue;
+}
+
+const std::string QuicSimpleTestServer::GetSimpleStatus() {
+  return kSimpleStatus;
+}
+
+const std::string QuicSimpleTestServer::GetSimpleHeaderName() {
+  return kSimpleHeaderName;
+}
+
+const std::string QuicSimpleTestServer::GetSimpleHeaderValue() {
+  return kSimpleHeaderValue;
+}
+
+void SetupQuicHttpResponseCache() {
+  SpdyHeaderBlock headers;
+  headers[kHelloHeaderName] = kHelloHeaderValue;
+  headers[kStatusHeader] = kHelloStatus;
+  SpdyHeaderBlock trailers;
+  trailers[kHelloTrailerName] = kHelloTrailerValue;
+  g_quic_response_cache = new QuicHttpResponseCache();
+  g_quic_response_cache->AddResponse(base::StringPrintf("%s", kTestServerHost),
+                                     kHelloPath, std::move(headers),
+                                     kHelloBodyValue, std::move(trailers));
+  headers[kSimpleHeaderName] = kSimpleHeaderValue;
+  headers[kStatusHeader] = kSimpleStatus;
+  g_quic_response_cache->AddResponse(base::StringPrintf("%s", kTestServerHost),
+                                     kSimplePath, std::move(headers),
+                                     kSimpleBodyValue);
+}
+
+void StartQuicServerOnServerThread(const base::FilePath& test_files_root,
+                                   base::WaitableEvent* server_started_event) {
+  DCHECK(g_quic_server_thread->task_runner()->BelongsToCurrentThread());
+  DCHECK(!g_quic_server);
+
+  QuicConfig config;
+  // Set up server certs.
+  base::FilePath directory;
+  directory = test_files_root;
+  std::unique_ptr<ProofSourceChromium> proof_source(new ProofSourceChromium());
+  CHECK(proof_source->Initialize(directory.AppendASCII("quic-chain.pem"),
+                                 directory.AppendASCII("quic-leaf-cert.key"),
+                                 base::FilePath()));
+  SetupQuicHttpResponseCache();
+
+  g_quic_server = new QuicSimpleServer(
+      std::move(proof_source), config, QuicCryptoServerConfig::ConfigOptions(),
+      AllSupportedVersions(), g_quic_response_cache);
+
+  // Start listening on an unbound port.
+  int rv = g_quic_server->Listen(IPEndPoint(IPAddress::IPv4AllZeros(), 0));
+  CHECK_GE(rv, 0) << "Quic server fails to start";
+  g_quic_server_port = g_quic_server->server_address().port();
+  server_started_event->Signal();
+}
+
+void ShutdownOnServerThread(base::WaitableEvent* server_stopped_event) {
+  DCHECK(g_quic_server_thread->task_runner()->BelongsToCurrentThread());
+  g_quic_server->Shutdown();
+  delete g_quic_server;
+  g_quic_server = nullptr;
+  delete g_quic_response_cache;
+  g_quic_response_cache = nullptr;
+  server_stopped_event->Signal();
+}
+
+void ShutdownDispatcherOnServerThread(
+    base::WaitableEvent* dispatcher_stopped_event) {
+  DCHECK(g_quic_server_thread->task_runner()->BelongsToCurrentThread());
+  g_quic_server->dispatcher()->Shutdown();
+  dispatcher_stopped_event->Signal();
+}
+
+bool QuicSimpleTestServer::Start() {
+  DVLOG(3) << g_quic_server_thread;
+  DCHECK(!g_quic_server_thread);
+  g_quic_server_thread = new base::Thread("quic server thread");
+  base::Thread::Options thread_options;
+  thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
+  bool started = g_quic_server_thread->StartWithOptions(thread_options);
+  DCHECK(started);
+  base::FilePath test_files_root = GetTestCertsDirectory();
+
+  base::WaitableEvent server_started_event(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  g_quic_server_thread->task_runner()->PostTask(
+      FROM_HERE, base::BindOnce(&StartQuicServerOnServerThread, test_files_root,
+                                &server_started_event));
+  server_started_event.Wait();
+  return true;
+}
+
+// Shut down the server dispatcher, and the stream should error out.
+void QuicSimpleTestServer::ShutdownDispatcherForTesting() {
+  if (!g_quic_server)
+    return;
+  DCHECK(!g_quic_server_thread->task_runner()->BelongsToCurrentThread());
+  base::WaitableEvent dispatcher_stopped_event(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  g_quic_server_thread->task_runner()->PostTask(
+      FROM_HERE, base::BindOnce(&ShutdownDispatcherOnServerThread,
+                                &dispatcher_stopped_event));
+  dispatcher_stopped_event.Wait();
+}
+
+void QuicSimpleTestServer::Shutdown() {
+  if (!g_quic_server)
+    return;
+  DCHECK(!g_quic_server_thread->task_runner()->BelongsToCurrentThread());
+  base::WaitableEvent server_stopped_event(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  g_quic_server_thread->task_runner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&ShutdownOnServerThread, &server_stopped_event));
+  server_stopped_event.Wait();
+  delete g_quic_server_thread;
+  g_quic_server_thread = nullptr;
+}
+
+int QuicSimpleTestServer::GetPort() {
+  return g_quic_server_port;
+}
+
+}  // namespace net
diff --git a/chromium/net/test/quic_simple_test_server.h b/chromium/net/test/quic_simple_test_server.h
new file mode 100644
index 00000000000..03ed5b72e67
--- /dev/null
+++ b/chromium/net/test/quic_simple_test_server.h
@@ -0,0 +1,60 @@
+// Copyright 2016 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.
+
+#ifndef NET_TEST_QUIC_SIMPLE_TEST_SERVER_H_
+#define NET_TEST_QUIC_SIMPLE_TEST_SERVER_H_
+
+#include <string>
+
+#include "url/gurl.h"
+
+namespace net {
+
+class QuicSimpleTestServer {
+ public:
+  static bool Start();
+  static void Shutdown();
+
+  // Shuts down the server dispatcher, which results in sending ConnectionClose
+  // frames to all connected clients.
+  static void ShutdownDispatcherForTesting();
+
+  // Returns example.com
+  static const std::string GetDomain();
+  // Returns test.example.com
+  static const std::string GetHost();
+  // Returns port number of the server.
+  static int GetPort();
+  // Returns test.example.com:port
+  static const std::string GetHostPort();
+
+  // Returns URL with host, port and file path, for example
+  // https://test.example.com:12345/{file_path}
+  static GURL GetFileURL(const std::string& file_path);
+
+  static const std::string GetStatusHeaderName();
+
+  // Server returns response with HTTP/2 headers and trailers. Does not include
+  // |port| as it is resolved differently: https://test.example.com/hello.txt
+  static GURL GetHelloURL();
+  static const std::string GetHelloPath();
+  static const std::string GetHelloBodyValue();
+  static const std::string GetHelloStatus();
+  static const std::string GetHelloHeaderName();
+  static const std::string GetHelloHeaderValue();
+  static const std::string GetHelloTrailerName();
+  static const std::string GetHelloTrailerValue();
+
+  // Server returns response without HTTP/2 trailers.
+  // https://test.example.com/simple.txt
+  static GURL GetSimpleURL();
+  static const std::string GetSimpleBodyValue();
+  static const std::string GetSimpleStatus();
+  static const std::string GetSimpleHeaderName();
+  static const std::string GetSimpleHeaderValue();
+};
+
+}  // namespace net
+
+#endif  // NET_TEST_QUIC_SIMPLE_TEST_SERVER_H_