BASELINE: Update Chromium to 68.0.3440.125

Change-Id: I23f19369e01f688e496f5bf179abb521ad73874f
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

21 files changed, 342 insertions, 172 deletions

diff --git a/chromium/net/test/embedded_test_server/default_handlers.cc b/chromium/net/test/embedded_test_server/default_handlers.cc
index 6d7375dede2..9a86da5d233 100644
--- a/chromium/net/test/embedded_test_server/default_handlers.cc
+++ b/chromium/net/test/embedded_test_server/default_handlers.cc
@@ -41,12 +41,6 @@ namespace net {
 namespace test_server {
 namespace {
 
-const UnescapeRule::Type kUnescapeAll =
-    UnescapeRule::SPACES | UnescapeRule::PATH_SEPARATORS |
-    UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
-    UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
-    UnescapeRule::REPLACE_PLUS_WITH_SPACE;
-
 const char kDefaultRealm[] = "testrealm";
 const char kDefaultPassword[] = "secret";
 const char kEtag[] = "abc";
@@ -254,7 +248,8 @@ std::unique_ptr<HttpResponse> HandleExpectAndSetCookie(
   if (got_all_expected) {
     for (const auto& cookie : query_list.at("set")) {
       http_response->AddCustomHeader(
-          "Set-Cookie", net::UnescapeURLComponent(cookie, kUnescapeAll));
+          "Set-Cookie", UnescapeBinaryURLComponent(
+                            cookie, UnescapeRule::REPLACE_PLUS_WITH_SPACE));
     }
   }
 
@@ -380,7 +375,7 @@ std::unique_ptr<HttpResponse> HandleAuthBasic(const HttpRequest& request) {
       base::FilePath().AppendASCII(request.relative_url.substr(1));
   if (file_path.FinalExtension() == FILE_PATH_LITERAL("gif")) {
     base::FilePath server_root;
-    PathService::Get(base::DIR_SOURCE_ROOT, &server_root);
+    base::PathService::Get(base::DIR_SOURCE_ROOT, &server_root);
     base::FilePath gif_path = server_root.AppendASCII(kLogoPath);
     std::string gif_data;
     base::ReadFileToString(gif_path, &gif_data);
@@ -503,8 +498,7 @@ std::unique_ptr<HttpResponse> HandleAuthDigest(const HttpRequest& request) {
 std::unique_ptr<HttpResponse> HandleServerRedirect(HttpStatusCode redirect_code,
                                                    const HttpRequest& request) {
   GURL request_url = request.GetURL();
-  std::string dest =
-      net::UnescapeURLComponent(request_url.query(), kUnescapeAll);
+  std::string dest = UnescapeBinaryURLComponent(request_url.query());
 
   std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
   http_response->set_code(redirect_code);
@@ -524,9 +518,8 @@ std::unique_ptr<HttpResponse> HandleCrossSiteRedirect(
   if (!ShouldHandle(request, "/cross-site"))
     return nullptr;
 
-  std::string dest_all = net::UnescapeURLComponent(
-      request.relative_url.substr(std::string("/cross-site").size() + 1),
-      kUnescapeAll);
+  std::string dest_all = UnescapeBinaryURLComponent(
+      request.relative_url.substr(std::string("/cross-site").size() + 1));
 
   std::string dest;
   size_t delimiter = dest_all.find("/");
@@ -550,8 +543,7 @@ std::unique_ptr<HttpResponse> HandleCrossSiteRedirect(
 // Returns a meta redirect to URL.
 std::unique_ptr<HttpResponse> HandleClientRedirect(const HttpRequest& request) {
   GURL request_url = request.GetURL();
-  std::string dest =
-      net::UnescapeURLComponent(request_url.query(), kUnescapeAll);
+  std::string dest = UnescapeBinaryURLComponent(request_url.query());
 
   std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
   http_response->set_content_type("text/html");
@@ -573,24 +565,6 @@ std::unique_ptr<HttpResponse> HandleDefaultResponse(
   return std::move(http_response);
 }
 
-// Delays |delay| seconds before sending a response to the client.
-class DelayedHttpResponse : public BasicHttpResponse {
- public:
-  explicit DelayedHttpResponse(double delay) : delay_(delay) {}
-
-  void SendResponse(const SendBytesCallback& send,
-                    const SendCompleteCallback& done) override {
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::BindOnce(send, ToResponseString(), done),
-        base::TimeDelta::FromSecondsD(delay_));
-  }
-
- private:
-  const double delay_;
-
-  DISALLOW_COPY_AND_ASSIGN(DelayedHttpResponse);
-};
-
 // /slow?N
 // Returns a response to the server delayed by N seconds.
 std::unique_ptr<HttpResponse> HandleSlowServer(const HttpRequest& request) {
@@ -601,7 +575,7 @@ std::unique_ptr<HttpResponse> HandleSlowServer(const HttpRequest& request) {
     delay = std::atof(request_url.query().c_str());
 
   std::unique_ptr<BasicHttpResponse> http_response(
-      new DelayedHttpResponse(delay));
+      new DelayedHttpResponse(base::TimeDelta::FromSecondsD(delay)));
   http_response->set_content_type("text/plain");
   http_response->set_content(base::StringPrintf("waited %.1f seconds", delay));
   return std::move(http_response);
diff --git a/chromium/net/test/embedded_test_server/embedded_test_server.cc b/chromium/net/test/embedded_test_server/embedded_test_server.cc
index 5caf5c59857..b3473bb5aa9 100644
--- a/chromium/net/test/embedded_test_server/embedded_test_server.cc
+++ b/chromium/net/test/embedded_test_server/embedded_test_server.cc
@@ -12,6 +12,7 @@
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_current.h"
 #include "base/path_service.h"
 #include "base/process/process_metrics.h"
 #include "base/run_loop.h"
@@ -300,26 +301,26 @@ scoped_refptr<X509Certificate> EmbeddedTestServer::GetCertificate() const {
 
 void EmbeddedTestServer::ServeFilesFromDirectory(
     const base::FilePath& directory) {
-  RegisterRequestHandler(base::Bind(&HandleFileRequest, directory));
+  RegisterDefaultHandler(base::Bind(&HandleFileRequest, directory));
 }
 
 void EmbeddedTestServer::ServeFilesFromSourceDirectory(
     const std::string& relative) {
   base::FilePath test_data_dir;
-  CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir));
+  CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir));
   ServeFilesFromDirectory(test_data_dir.AppendASCII(relative));
 }
 
 void EmbeddedTestServer::ServeFilesFromSourceDirectory(
     const base::FilePath& relative) {
   base::FilePath test_data_dir;
-  CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir));
+  CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir));
   ServeFilesFromDirectory(test_data_dir.Append(relative));
 }
 
 void EmbeddedTestServer::AddDefaultHandlers(const base::FilePath& directory) {
-  RegisterDefaultHandlers(this);
   ServeFilesFromSourceDirectory(directory);
+  RegisterDefaultHandlers(this);
 }
 
 void EmbeddedTestServer::RegisterRequestHandler(
@@ -351,13 +352,10 @@ std::unique_ptr<StreamSocket> EmbeddedTestServer::DoSSLUpgrade(
 }
 
 void EmbeddedTestServer::DoAcceptLoop() {
-  int rv = OK;
-  while (rv == OK) {
-    rv = listen_socket_->Accept(
-        &accepted_socket_, base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
-                                      base::Unretained(this)));
-    if (rv == ERR_IO_PENDING)
-      return;
+  while (
+      listen_socket_->Accept(&accepted_socket_,
+                             base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
+                                        base::Unretained(this))) == OK) {
     HandleAcceptResult(std::move(accepted_socket_));
   }
 }
@@ -479,7 +477,7 @@ bool EmbeddedTestServer::PostTaskToIOThreadAndWait(
   // To handle this situation, create temporary message loop to support the
   // PostTaskAndReply operation if the current thread as no message loop.
   std::unique_ptr<base::MessageLoop> temporary_loop;
-  if (!base::MessageLoop::current())
+  if (!base::MessageLoopCurrent::Get())
     temporary_loop.reset(new base::MessageLoop());
 
   base::RunLoop run_loop;
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 d6f74a11c10..2e257dee787 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
@@ -28,6 +28,7 @@
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/test/embedded_test_server/request_handler_util.h"
 #include "net/test/gtest_util.h"
+#include "net/test/test_with_scoped_task_environment.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
@@ -117,13 +118,13 @@ class TestConnectionListener
 
 class EmbeddedTestServerTest
     : public testing::TestWithParam<EmbeddedTestServer::Type>,
-      public URLFetcherDelegate {
+      public URLFetcherDelegate,
+      public WithScopedTaskEnvironment {
  public:
   EmbeddedTestServerTest()
       : num_responses_received_(0),
         num_responses_expected_(0),
-        io_thread_("io_thread") {
-  }
+        io_thread_("io_thread") {}
 
   void SetUp() override {
     base::Thread::Options thread_options;
@@ -250,7 +251,7 @@ TEST_P(EmbeddedTestServerTest, RegisterRequestHandler) {
 
 TEST_P(EmbeddedTestServerTest, ServeFilesFromDirectory) {
   base::FilePath src_dir;
-  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
+  ASSERT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
   server_->ServeFilesFromDirectory(
       src_dir.AppendASCII("net").AppendASCII("data"));
   ASSERT_TRUE(server_->Start());
@@ -270,7 +271,7 @@ TEST_P(EmbeddedTestServerTest, ServeFilesFromDirectory) {
 
 TEST_P(EmbeddedTestServerTest, MockHeadersWithoutCRLF) {
   base::FilePath src_dir;
-  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
+  ASSERT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
   server_->ServeFilesFromDirectory(
       src_dir.AppendASCII("net").AppendASCII("data").AppendASCII(
           "embedded_test_server"));
@@ -499,7 +500,8 @@ INSTANTIATE_TEST_CASE_P(EmbeddedTestServerTestInstantiation,
 typedef std::tuple<bool, bool, EmbeddedTestServer::Type> ThreadingTestParams;
 
 class EmbeddedTestServerThreadingTest
-    : public testing::TestWithParam<ThreadingTestParams> {};
+    : public testing::TestWithParam<ThreadingTestParams>,
+      public WithScopedTaskEnvironment {};
 
 class EmbeddedTestServerThreadingTestDelegate
     : public base::PlatformThread::Delegate,
@@ -529,7 +531,7 @@ class EmbeddedTestServerThreadingTestDelegate
     // Create the test server instance.
     EmbeddedTestServer server(type_);
     base::FilePath src_dir;
-    ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
+    ASSERT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
     ASSERT_TRUE(server.Start());
 
     // Make a request and wait for the reply.
diff --git a/chromium/net/test/embedded_test_server/http_response.cc b/chromium/net/test/embedded_test_server/http_response.cc
index 168049e2695..cc5e99b826a 100644
--- a/chromium/net/test/embedded_test_server/http_response.cc
+++ b/chromium/net/test/embedded_test_server/http_response.cc
@@ -4,10 +4,12 @@
 
 #include "net/test/embedded_test_server/http_response.h"
 
+#include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "net/http/http_status_code.h"
 
 namespace net {
@@ -85,6 +87,17 @@ void BasicHttpResponse::SendResponse(const SendBytesCallback& send,
   send.Run(ToResponseString(), done);
 }
 
+DelayedHttpResponse::DelayedHttpResponse(const base::TimeDelta delay)
+    : delay_(delay) {}
+
+DelayedHttpResponse::~DelayedHttpResponse() = default;
+
+void DelayedHttpResponse::SendResponse(const SendBytesCallback& send,
+                                       const SendCompleteCallback& done) {
+  base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::BindOnce(send, ToResponseString(), done), delay_);
+}
+
 void HungResponse::SendResponse(const SendBytesCallback& send,
                                 const SendCompleteCallback& done) {}
 
diff --git a/chromium/net/test/embedded_test_server/http_response.h b/chromium/net/test/embedded_test_server/http_response.h
index 407a8636f39..d78dda259c0 100644
--- a/chromium/net/test/embedded_test_server/http_response.h
+++ b/chromium/net/test/embedded_test_server/http_response.h
@@ -11,6 +11,7 @@
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
+#include "base/time/time.h"
 #include "net/http/http_status_code.h"
 
 namespace net {
@@ -79,6 +80,22 @@ class BasicHttpResponse : public HttpResponse {
   DISALLOW_COPY_AND_ASSIGN(BasicHttpResponse);
 };
 
+class DelayedHttpResponse : public BasicHttpResponse {
+ public:
+  DelayedHttpResponse(const base::TimeDelta delay);
+  ~DelayedHttpResponse() override;
+
+  // Issues a delayed send to the to the task runner.
+  void SendResponse(const SendBytesCallback& send,
+                    const SendCompleteCallback& done) override;
+
+ private:
+  // The delay time for the response.
+  const base::TimeDelta delay_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelayedHttpResponse);
+};
+
 class RawHttpResponse : public HttpResponse {
  public:
   RawHttpResponse(const std::string& headers, const std::string& contents);
diff --git a/chromium/net/test/embedded_test_server/request_handler_util.cc b/chromium/net/test/embedded_test_server/request_handler_util.cc
index c064c0762d5..f0efe4de91a 100644
--- a/chromium/net/test/embedded_test_server/request_handler_util.cc
+++ b/chromium/net/test/embedded_test_server/request_handler_util.cc
@@ -27,12 +27,6 @@ namespace net {
 namespace test_server {
 namespace {
 
-const UnescapeRule::Type kUnescapeAll =
-    UnescapeRule::SPACES | UnescapeRule::PATH_SEPARATORS |
-    UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
-    UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
-    UnescapeRule::REPLACE_PLUS_WITH_SPACE;
-
 std::string GetContentType(const base::FilePath& path) {
   if (path.MatchesExtension(FILE_PATH_LITERAL(".crx")))
     return "application/x-chrome-extension";
@@ -92,8 +86,9 @@ std::unique_ptr<HttpResponse> HandlePrefixedRequest(
 RequestQuery ParseQuery(const GURL& url) {
   RequestQuery queries;
   for (QueryIterator it(url); !it.IsAtEnd(); it.Advance()) {
-    queries[net::UnescapeURLComponent(it.GetKey(), kUnescapeAll)].push_back(
-        it.GetUnescapedValue());
+    queries[UnescapeBinaryURLComponent(it.GetKey(),
+                                       UnescapeRule::REPLACE_PLUS_WITH_SPACE)]
+        .push_back(it.GetUnescapedValue());
   }
   return queries;
 }
diff --git a/chromium/net/test/net_test_suite.cc b/chromium/net/test/net_test_suite.cc
index d26e50e4326..ff4a28851d1 100644
--- a/chromium/net/test/net_test_suite.cc
+++ b/chromium/net/test/net_test_suite.cc
@@ -7,13 +7,10 @@
 #include "base/logging.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_stream_factory.h"
-#include "net/spdy/chromium/spdy_session.h"
+#include "net/spdy/spdy_session.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
-base::test::ScopedTaskEnvironment::MainThreadType kDefaultMainThreadType =
-    base::test::ScopedTaskEnvironment::MainThreadType::IO;
-
 NetTestSuite* g_current_net_test_suite = nullptr;
 }  // namespace
 
@@ -34,32 +31,9 @@ void NetTestSuite::Initialize() {
 }
 
 void NetTestSuite::Shutdown() {
-  // We want to destroy this here before the TestSuite continues to tear down
-  // the environment.
-  scoped_task_environment_.reset();
-
   TestSuite::Shutdown();
 }
 
-// static
-base::test::ScopedTaskEnvironment* NetTestSuite::GetScopedTaskEnvironment() {
-  DCHECK(g_current_net_test_suite);
-  return g_current_net_test_suite->scoped_task_environment_.get();
-}
-
-// static
-void NetTestSuite::SetScopedTaskEnvironment(
-    base::test::ScopedTaskEnvironment::MainThreadType type) {
-  g_current_net_test_suite->scoped_task_environment_ = nullptr;
-  g_current_net_test_suite->scoped_task_environment_ =
-      std::make_unique<base::test::ScopedTaskEnvironment>(type);
-}
-
-// static
-void NetTestSuite::ResetScopedTaskEnvironment() {
-  SetScopedTaskEnvironment(kDefaultMainThreadType);
-}
-
 void NetTestSuite::InitializeTestThread() {
   network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
 
@@ -73,8 +47,4 @@ void NetTestSuite::InitializeTestThreadNoNetworkChangeNotifier() {
   // be mapped to localhost.  This prevents DNS queries from being sent in
   // the process of running these unit tests.
   host_resolver_proc_->AddRule("*", "127.0.0.1");
-
-  scoped_task_environment_ =
-      std::make_unique<base::test::ScopedTaskEnvironment>(
-          kDefaultMainThreadType);
 }
diff --git a/chromium/net/test/net_test_suite.h b/chromium/net/test/net_test_suite.h
index a35a30c90e3..591db73eb12 100644
--- a/chromium/net/test/net_test_suite.h
+++ b/chromium/net/test/net_test_suite.h
@@ -8,7 +8,6 @@
 #include <memory>
 
 #include "base/memory/ref_counted.h"
-#include "base/test/scoped_task_environment.h"
 #include "base/test/test_suite.h"
 #include "build/build_config.h"
 #include "net/dns/mock_host_resolver.h"
@@ -32,20 +31,6 @@ class NetTestSuite : public base::TestSuite {
 
   void Shutdown() override;
 
-  // Returns the base::test::ScopedTaskEnvironment initialized by the current
-  // NetTestSuite.
-  static base::test::ScopedTaskEnvironment* GetScopedTaskEnvironment();
-
-  // Sets the global ScopedTaskEnvironment with a new environment of main thread
-  // type, |type|. For example, one might want to use a MOCK_TIME
-  // ScopedTaskEnvironment.
-  static void SetScopedTaskEnvironment(
-      base::test::ScopedTaskEnvironment::MainThreadType type);
-
-  // Sets the global ScopedTaskEnvironment to a new environment of the default
-  // type used by NetTestSuite.
-  static void ResetScopedTaskEnvironment();
-
  protected:
   // Called from within Initialize(), but separate so that derived classes
   // can initialize the NetTestSuite instance only and not
@@ -61,7 +46,6 @@ class NetTestSuite : public base::TestSuite {
 
  private:
   std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-  std::unique_ptr<base::test::ScopedTaskEnvironment> scoped_task_environment_;
   scoped_refptr<net::RuleBasedHostResolverProc> host_resolver_proc_;
   net::ScopedDefaultHostResolverProc scoped_host_resolver_proc_;
 };
diff --git a/chromium/net/test/python_utils.cc b/chromium/net/test/python_utils.cc
index e439813a8c5..9548d988b9b 100644
--- a/chromium/net/test/python_utils.cc
+++ b/chromium/net/test/python_utils.cc
@@ -61,7 +61,7 @@ void AppendToPythonPath(const base::FilePath& dir) {
 bool GetPyProtoPath(base::FilePath* dir) {
   // Locate the Python code generated by the protocol buffers compiler.
   base::FilePath generated_code_dir;
-  if (!PathService::Get(base::DIR_EXE, &generated_code_dir)) {
+  if (!base::PathService::Get(base::DIR_EXE, &generated_code_dir)) {
     LOG(ERROR) << "Can't find " << generated_code_dir.value();
     return false;
   }
diff --git a/chromium/net/test/quic_simple_test_server.cc b/chromium/net/test/quic_simple_test_server.cc
index 0f11650274e..13eccd0d9c4 100644
--- a/chromium/net/test/quic_simple_test_server.cc
+++ b/chromium/net/test/quic_simple_test_server.cc
@@ -19,10 +19,10 @@
 #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/third_party/quic/core/quic_dispatcher.h"
+#include "net/third_party/quic/tools/quic_memory_cache_backend.h"
+#include "net/third_party/spdy/core/spdy_header_block.h"
 #include "net/tools/quic/quic_simple_server.h"
 
 namespace {
@@ -51,7 +51,7 @@ 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::QuicMemoryCacheBackend* g_quic_cache_backend = nullptr;
 net::QuicSimpleServer* g_quic_server = nullptr;
 int g_quic_server_port = 0;
 
@@ -131,21 +131,21 @@ const std::string QuicSimpleTestServer::GetSimpleHeaderValue() {
   return kSimpleHeaderValue;
 }
 
-void SetupQuicHttpResponseCache() {
-  SpdyHeaderBlock headers;
+void SetupQuicMemoryCacheBackend() {
+  spdy::SpdyHeaderBlock headers;
   headers[kHelloHeaderName] = kHelloHeaderValue;
   headers[kStatusHeader] = kHelloStatus;
-  SpdyHeaderBlock trailers;
+  spdy::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));
+  g_quic_cache_backend = new QuicMemoryCacheBackend();
+  g_quic_cache_backend->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);
+  g_quic_cache_backend->AddResponse(base::StringPrintf("%s", kTestServerHost),
+                                    kSimplePath, std::move(headers),
+                                    kSimpleBodyValue);
 }
 
 void StartQuicServerOnServerThread(const base::FilePath& test_files_root,
@@ -161,11 +161,11 @@ void StartQuicServerOnServerThread(const base::FilePath& test_files_root,
   CHECK(proof_source->Initialize(directory.AppendASCII("quic-chain.pem"),
                                  directory.AppendASCII("quic-leaf-cert.key"),
                                  base::FilePath()));
-  SetupQuicHttpResponseCache();
+  SetupQuicMemoryCacheBackend();
 
   g_quic_server = new QuicSimpleServer(
       std::move(proof_source), config, QuicCryptoServerConfig::ConfigOptions(),
-      AllSupportedVersions(), g_quic_response_cache);
+      AllSupportedVersions(), g_quic_cache_backend);
 
   // Start listening on an unbound port.
   int rv = g_quic_server->Listen(IPEndPoint(IPAddress::IPv4AllZeros(), 0));
@@ -179,8 +179,8 @@ void ShutdownOnServerThread(base::WaitableEvent* server_stopped_event) {
   g_quic_server->Shutdown();
   delete g_quic_server;
   g_quic_server = nullptr;
-  delete g_quic_response_cache;
-  g_quic_response_cache = nullptr;
+  delete g_quic_cache_backend;
+  g_quic_cache_backend = nullptr;
   server_stopped_event->Signal();
 }
 
diff --git a/chromium/net/test/spawned_test_server/base_test_server.cc b/chromium/net/test/spawned_test_server/base_test_server.cc
index 75a4cf8dbf1..b0c7dd5ac71 100644
--- a/chromium/net/test/spawned_test_server/base_test_server.cc
+++ b/chromium/net/test/spawned_test_server/base_test_server.cc
@@ -25,6 +25,7 @@
 #include "net/cert/x509_certificate.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log_with_source.h"
+#include "net/test/test_data_directory.h"
 #include "url/gurl.h"
 
 namespace net {
@@ -106,7 +107,7 @@ bool GetLocalCertificatesDir(const base::FilePath& certificates_dir,
   }
 
   base::FilePath src_dir;
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
     return false;
 
   *local_certificates_dir = src_dir.Append(certificates_dir);
@@ -157,11 +158,34 @@ std::string OCSPDateToString(
       return "early";
     case BaseTestServer::SSLOptions::OCSP_DATE_LONG:
       return "long";
+    case BaseTestServer::SSLOptions::OCSP_DATE_LONGER:
+      return "longer";
   }
   NOTREACHED();
   return std::string();
 }
 
+std::string OCSPProducedToString(
+    BaseTestServer::SSLOptions::OCSPProduced ocsp_produced) {
+  switch (ocsp_produced) {
+    case BaseTestServer::SSLOptions::OCSPProduced::OCSP_PRODUCED_VALID:
+      return "valid";
+    case BaseTestServer::SSLOptions::OCSPProduced::OCSP_PRODUCED_BEFORE_CERT:
+      return "before";
+    case BaseTestServer::SSLOptions::OCSPProduced::OCSP_PRODUCED_AFTER_CERT:
+      return "after";
+    default:
+      NOTREACHED();
+      return std::string();
+  }
+}
+
+bool RegisterRootCertsInternal(const base::FilePath& file_path) {
+  TestRootCerts* root_certs = TestRootCerts::GetInstance();
+  return root_certs->AddFromFile(file_path.AppendASCII("ocsp-test-root.pem")) &&
+         root_certs->AddFromFile(file_path.AppendASCII("root_ca_cert.pem"));
+}
+
 }  // namespace
 
 BaseTestServer::SSLOptions::SSLOptions() = default;
@@ -187,6 +211,7 @@ base::FilePath BaseTestServer::SSLOptions::GetCertificateFile() const {
     case CERT_BAD_VALIDITY:
       return base::FilePath(FILE_PATH_LITERAL("bad_validity.pem"));
     case CERT_AUTO:
+    case CERT_AUTO_WITH_INTERMEDIATE:
     case CERT_AUTO_AIA_INTERMEDIATE:
       return base::FilePath();
     default:
@@ -196,8 +221,10 @@ base::FilePath BaseTestServer::SSLOptions::GetCertificateFile() const {
 }
 
 std::string BaseTestServer::SSLOptions::GetOCSPArgument() const {
-  if (server_certificate != CERT_AUTO)
+  if (server_certificate != CERT_AUTO &&
+      server_certificate != CERT_AUTO_WITH_INTERMEDIATE) {
     return std::string();
+  }
 
   // |ocsp_responses| overrides when it is non-empty.
   if (!ocsp_responses.empty()) {
@@ -214,8 +241,10 @@ std::string BaseTestServer::SSLOptions::GetOCSPArgument() const {
 }
 
 std::string BaseTestServer::SSLOptions::GetOCSPDateArgument() const {
-  if (server_certificate != CERT_AUTO)
+  if (server_certificate != CERT_AUTO &&
+      server_certificate != CERT_AUTO_WITH_INTERMEDIATE) {
     return std::string();
+  }
 
   if (!ocsp_responses.empty()) {
     std::string arg;
@@ -231,20 +260,56 @@ std::string BaseTestServer::SSLOptions::GetOCSPDateArgument() const {
 }
 
 std::string BaseTestServer::SSLOptions::GetOCSPProducedArgument() const {
-  if (server_certificate != CERT_AUTO)
+  if (server_certificate != CERT_AUTO &&
+      server_certificate != CERT_AUTO_WITH_INTERMEDIATE) {
     return std::string();
+  }
 
-  switch (ocsp_produced) {
-    case OCSP_PRODUCED_VALID:
-      return "valid";
-    case OCSP_PRODUCED_BEFORE_CERT:
-      return "before";
-    case OCSP_PRODUCED_AFTER_CERT:
-      return "after";
-    default:
-      NOTREACHED();
-      return std::string();
+  return OCSPProducedToString(ocsp_produced);
+}
+
+std::string BaseTestServer::SSLOptions::GetOCSPIntermediateArgument() const {
+  if (server_certificate != CERT_AUTO_WITH_INTERMEDIATE)
+    return std::string();
+
+  // |ocsp_intermediate_responses| overrides when it is non-empty.
+  if (!ocsp_intermediate_responses.empty()) {
+    std::string arg;
+    for (size_t i = 0; i < ocsp_intermediate_responses.size(); i++) {
+      if (i != 0)
+        arg += ":";
+      arg += OCSPStatusToString(ocsp_intermediate_responses[i].status);
+    }
+    return arg;
+  }
+
+  return OCSPStatusToString(ocsp_intermediate_status);
+}
+
+std::string BaseTestServer::SSLOptions::GetOCSPIntermediateDateArgument()
+    const {
+  if (server_certificate != CERT_AUTO_WITH_INTERMEDIATE)
+    return std::string();
+
+  if (!ocsp_intermediate_responses.empty()) {
+    std::string arg;
+    for (size_t i = 0; i < ocsp_intermediate_responses.size(); i++) {
+      if (i != 0)
+        arg += ":";
+      arg += OCSPDateToString(ocsp_intermediate_responses[i].date);
+    }
+    return arg;
   }
+
+  return OCSPDateToString(ocsp_intermediate_date);
+}
+
+std::string BaseTestServer::SSLOptions::GetOCSPIntermediateProducedArgument()
+    const {
+  if (server_certificate != CERT_AUTO_WITH_INTERMEDIATE)
+    return std::string();
+
+  return OCSPProducedToString(ocsp_intermediate_produced);
 }
 
 BaseTestServer::BaseTestServer(Type type) : type_(type) {
@@ -377,6 +442,11 @@ bool BaseTestServer::GetFilePathWithReplacements(
   return true;
 }
 
+void BaseTestServer::RegisterTestCerts() {
+  bool added_root_certs = RegisterRootCertsInternal(GetTestCertsDirectory());
+  DCHECK(added_root_certs);
+}
+
 bool BaseTestServer::LoadTestRootCert() const {
   TestRootCerts* root_certs = TestRootCerts::GetInstance();
   if (!root_certs)
@@ -387,15 +457,7 @@ bool BaseTestServer::LoadTestRootCert() const {
   if (!GetLocalCertificatesDir(certificates_dir_, &root_certificate_path))
     return false;
 
-  if (ssl_options_.server_certificate == SSLOptions::CERT_AUTO ||
-      ssl_options_.server_certificate ==
-          SSLOptions::CERT_AUTO_AIA_INTERMEDIATE) {
-    return root_certs->AddFromFile(
-        root_certificate_path.AppendASCII("ocsp-test-root.pem"));
-  } else {
-    return root_certs->AddFromFile(
-        root_certificate_path.AppendASCII("root_ca_cert.pem"));
-  }
+  return RegisterRootCertsInternal(root_certificate_path);
 }
 
 scoped_refptr<X509Certificate> BaseTestServer::GetCertificate() const {
@@ -576,6 +638,25 @@ bool BaseTestServer::GenerateArguments(base::DictionaryValue* arguments) const {
     if (!ocsp_produced_arg.empty())
       arguments->SetString("ocsp-produced", ocsp_produced_arg);
 
+    std::string ocsp_intermediate_arg =
+        ssl_options_.GetOCSPIntermediateArgument();
+    if (!ocsp_intermediate_arg.empty())
+      arguments->SetString("ocsp-intermediate", ocsp_intermediate_arg);
+
+    std::string ocsp_intermediate_date_arg =
+        ssl_options_.GetOCSPIntermediateDateArgument();
+    if (!ocsp_intermediate_date_arg.empty()) {
+      arguments->SetString("ocsp-intermediate-date",
+                           ocsp_intermediate_date_arg);
+    }
+
+    std::string ocsp_intermediate_produced_arg =
+        ssl_options_.GetOCSPIntermediateProducedArgument();
+    if (!ocsp_intermediate_produced_arg.empty()) {
+      arguments->SetString("ocsp-intermediate-produced",
+                           ocsp_intermediate_produced_arg);
+    }
+
     if (ssl_options_.cert_serial != 0) {
       arguments->SetInteger("cert-serial", ssl_options_.cert_serial);
     }
diff --git a/chromium/net/test/spawned_test_server/base_test_server.h b/chromium/net/test/spawned_test_server/base_test_server.h
index c279b6cf21d..56b6a7bdb6b 100644
--- a/chromium/net/test/spawned_test_server/base_test_server.h
+++ b/chromium/net/test/spawned_test_server/base_test_server.h
@@ -58,6 +58,10 @@ class BaseTestServer {
       // CERT_AUTO causes the testserver to generate a test certificate issued
       // by "Testing CA" (see net/data/ssl/certificates/ocsp-test-root.pem).
       CERT_AUTO,
+      // As with CERT_AUTO, but the chain will include a generated intermediate
+      // as well. The testserver will include the intermediate cert in the TLS
+      // handshake.
+      CERT_AUTO_WITH_INTERMEDIATE,
       // Generate an intermediate cert issued by "Testing CA", and generate a
       // test certificate issued by that intermediate with an AIA record for
       // retrieving the intermediate.
@@ -100,6 +104,7 @@ class BaseTestServer {
       OCSP_DATE_OLD,
       OCSP_DATE_EARLY,
       OCSP_DATE_LONG,
+      OCSP_DATE_LONGER,
     };
 
     // OCSPSingleResponse is used when specifying multiple stapled responses,
@@ -192,27 +197,66 @@ class BaseTestServer {
     // to testserver or the empty string if there is none.
     std::string GetOCSPProducedArgument() const;
 
+    // GetOCSPIntermediateArgument returns the value of any OCSP intermediate
+    // argument to testserver or the empty string if there is none.
+    std::string GetOCSPIntermediateArgument() const;
+
+    // GetOCSPIntermediateDateArgument returns the value of the OCSP
+    // intermediate date argument to testserver or the empty string if there is
+    // none.
+    std::string GetOCSPIntermediateDateArgument() const;
+
+    // GetOCSPIntermediateProducedArgument returns the value of the OCSP
+    // intermediate produced argument to testserver or the empty string if
+    // there is none.
+    std::string GetOCSPIntermediateProducedArgument() const;
+
     // The certificate to use when serving requests.
     ServerCertificate server_certificate = CERT_OK;
 
-    // If |server_certificate==CERT_AUTO| then this determines the type of OCSP
-    // response returned. Ignored if |ocsp_responses| is non-empty.
+    // If |server_certificate==CERT_AUTO| or |CERT_AUTO_WITH_INTERMEDIATE| then
+    // this determines the type of leaf OCSP response returned. Ignored if
+    // |ocsp_responses| is non-empty.
     OCSPStatus ocsp_status = OCSP_OK;
 
-    // If |server_certificate==CERT_AUTO| then this determines the date range
-    // set on the OCSP response returned. Ignore if |ocsp_responses| is
-    // non-empty.
+    // If |server_certificate==CERT_AUTO| or |CERT_AUTO_WITH_INTERMEDIATE| then
+    // this determines the date range set on the leaf OCSP response returned.
+    // Ignore if |ocsp_responses| is non-empty.
     OCSPDate ocsp_date = OCSP_DATE_VALID;
 
-    // If |server_certificate==CERT_AUTO|, contains the status and validity for
-    // multiple stapled responeses. Overrides |ocsp_status| and |ocsp_date| when
+    // If |server_certificate==CERT_AUTO| or |CERT_AUTO_WITH_INTERMEDIATE|,
+    // contains the status and validity for multiple stapled responeses.
+    // Overrides |ocsp_status| and |ocsp_date| when
     // non-empty.
     std::vector<OCSPSingleResponse> ocsp_responses;
 
-    // If |server_certificate==CERT_AUTO| then this determines the validity of
-    // the producedAt field on the returned OCSP response.
+    // If |server_certificate==CERT_AUTO| or |CERT_AUTO_WITH_INTERMEDIATE| then
+    // this determines the validity of the producedAt field on the returned
+    // leaf OCSP response.
     OCSPProduced ocsp_produced = OCSP_PRODUCED_VALID;
 
+    // If |server_certificate==CERT_AUTO_WITH_INTERMEDIATE| then this
+    // determines the type of intermediate OCSP response returned. Ignored if
+    // |ocsp_intermediate_responses| is non-empty.
+    OCSPStatus ocsp_intermediate_status = OCSP_OK;
+
+    // If |server_certificate==CERT_AUTO_WITH_INTERMEDIATE| then this
+    // determines the date range set on the intermediate OCSP response
+    // returned. Ignore if |ocsp_intermediate_responses| is non-empty.
+    OCSPDate ocsp_intermediate_date = OCSP_DATE_VALID;
+
+    // If |server_certificate==CERT_AUTO_WITH_INTERMEDIATE|, contains the
+    // status and validity for multiple stapled responeses. Overrides
+    // |ocsp_intermediate_status| and |ocsp_intermediate_date| when non-empty.
+    // TODO(mattm): testserver doesn't actually staple OCSP responses for
+    // intermediates.
+    std::vector<OCSPSingleResponse> ocsp_intermediate_responses;
+
+    // If |server_certificate==CERT_AUTO_WITH_INTERMEDIATE| then this
+    // determines the validity of the producedAt field on the returned
+    // intermediate OCSP response.
+    OCSPProduced ocsp_intermediate_produced = OCSP_PRODUCED_VALID;
+
     // If not zero, |cert_serial| will be the serial number of the
     // auto-generated leaf certificate when |server_certificate==CERT_AUTO|.
     uint64_t cert_serial = 0;
@@ -375,6 +419,9 @@ class BaseTestServer {
     redirect_connect_to_localhost_ = redirect_connect_to_localhost;
   }
 
+  // Registers the test server's certs for the current process.
+  static void RegisterTestCerts();
+
   // Marks the root certificate of an HTTPS test server as trusted for
   // the duration of tests.
   bool LoadTestRootCert() const WARN_UNUSED_RESULT;
diff --git a/chromium/net/test/spawned_test_server/local_test_server.cc b/chromium/net/test/spawned_test_server/local_test_server.cc
index 6a7fcac66a8..8946456a0bd 100644
--- a/chromium/net/test/spawned_test_server/local_test_server.cc
+++ b/chromium/net/test/spawned_test_server/local_test_server.cc
@@ -77,7 +77,7 @@ LocalTestServer::~LocalTestServer() {
 
 bool LocalTestServer::GetTestServerPath(base::FilePath* testserver_path) const {
   base::FilePath testserver_dir;
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &testserver_dir)) {
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT, &testserver_dir)) {
     LOG(ERROR) << "Failed to get DIR_SOURCE_ROOT";
     return false;
   }
@@ -148,7 +148,7 @@ bool LocalTestServer::Init(const base::FilePath& document_root) {
   DCHECK(!GetPort());
 
   base::FilePath src_dir;
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
     return false;
   SetResourcePath(src_dir.Append(document_root),
                   src_dir.AppendASCII("net")
@@ -162,7 +162,7 @@ bool LocalTestServer::SetPythonPath() const {
   ClearPythonPath();
 
   base::FilePath third_party_dir;
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &third_party_dir)) {
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT, &third_party_dir)) {
     LOG(ERROR) << "Failed to get DIR_SOURCE_ROOT";
     return false;
   }
diff --git a/chromium/net/test/spawned_test_server/local_test_server_posix.cc b/chromium/net/test/spawned_test_server/local_test_server_posix.cc
index 71fd803b785..0ba4ee34b71 100644
--- a/chromium/net/test/spawned_test_server/local_test_server_posix.cc
+++ b/chromium/net/test/spawned_test_server/local_test_server_posix.cc
@@ -141,7 +141,8 @@ bool LocalTestServer::LaunchPython(const base::FilePath& testserver_path) {
   base::LaunchOptions options;
 
   // Set CWD to source root.
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &options.current_directory)) {
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT,
+                              &options.current_directory)) {
     LOG(ERROR) << "Failed to get DIR_SOURCE_ROOT";
     return false;
   }
diff --git a/chromium/net/test/spawned_test_server/local_test_server_win.cc b/chromium/net/test/spawned_test_server/local_test_server_win.cc
index 6d5517b9ac4..274b2783ab3 100644
--- a/chromium/net/test/spawned_test_server/local_test_server_win.cc
+++ b/chromium/net/test/spawned_test_server/local_test_server_win.cc
@@ -11,7 +11,6 @@
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
-#include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/single_thread_task_runner.h"
@@ -128,8 +127,8 @@ bool LocalTestServer::LaunchPython(const base::FilePath& testserver_path) {
   base::LaunchOptions launch_options;
 
   // Set CWD to source root.
-  if (!PathService::Get(base::DIR_SOURCE_ROOT,
-                        &launch_options.current_directory)) {
+  if (!base::PathService::Get(base::DIR_SOURCE_ROOT,
+                              &launch_options.current_directory)) {
     LOG(ERROR) << "Failed to get DIR_SOURCE_ROOT";
     return false;
   }
diff --git a/chromium/net/test/spawned_test_server/remote_test_server.cc b/chromium/net/test/spawned_test_server/remote_test_server.cc
index 210cb6137a7..20d96ccd16c 100644
--- a/chromium/net/test/spawned_test_server/remote_test_server.cc
+++ b/chromium/net/test/spawned_test_server/remote_test_server.cc
@@ -190,7 +190,7 @@ bool RemoteTestServer::Stop() {
 // device.
 base::FilePath RemoteTestServer::GetDocumentRoot() const {
   base::FilePath src_dir;
-  PathService::Get(base::DIR_SOURCE_ROOT, &src_dir);
+  base::PathService::Get(base::DIR_SOURCE_ROOT, &src_dir);
   return src_dir.Append(document_root());
 }
 
diff --git a/chromium/net/test/spawned_test_server/remote_test_server_config.cc b/chromium/net/test/spawned_test_server/remote_test_server_config.cc
index 38ea63e6378..125ec6f8490 100644
--- a/chromium/net/test/spawned_test_server/remote_test_server_config.cc
+++ b/chromium/net/test/spawned_test_server/remote_test_server_config.cc
@@ -16,6 +16,10 @@
 #include "build/build_config.h"
 #include "url/gurl.h"
 
+#if defined(OS_FUCHSIA)
+#include "base/base_paths_fuchsia.h"
+#endif
+
 namespace net {
 
 namespace {
@@ -23,11 +27,11 @@ namespace {
 base::FilePath GetTestServerConfigFilePath() {
   base::FilePath dir;
 #if defined(OS_ANDROID)
-  PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, &dir);
+  base::PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, &dir);
 #elif defined(OS_FUCHSIA)
-  dir = base::FilePath("/system");
+  dir = base::FilePath("/data");
 #else
-  PathService::Get(base::DIR_TEMP, &dir);
+  base::PathService::Get(base::DIR_TEMP, &dir);
 #endif
   return dir.AppendASCII("net-test-server-config");
 }
diff --git a/chromium/net/test/tcp_socket_proxy_unittest.cc b/chromium/net/test/tcp_socket_proxy_unittest.cc
index ea321ad2c86..864404c9088 100644
--- a/chromium/net/test/tcp_socket_proxy_unittest.cc
+++ b/chromium/net/test/tcp_socket_proxy_unittest.cc
@@ -12,6 +12,7 @@
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_server_socket.h"
 #include "net/test/gtest_util.h"
+#include "net/test/test_with_scoped_task_environment.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -20,7 +21,7 @@ using net::test::IsOk;
 
 namespace net {
 
-class TcpSocketProxyTest : public testing::Test {
+class TcpSocketProxyTest : public TestWithScopedTaskEnvironment {
  public:
   TcpSocketProxyTest() : io_thread_("TcpSocketProxyTest IO Thread") {
     EXPECT_TRUE(io_thread_.StartWithOptions(
@@ -104,6 +105,8 @@ class TcpSocketProxyTest : public testing::Test {
   std::unique_ptr<TCPServerSocket> listen_socket_;
 
   std::unique_ptr<TcpSocketProxy> proxy_;
+
+ private:
   IPEndPoint proxy_address_;
 };
 
diff --git a/chromium/net/test/test_data_directory.cc b/chromium/net/test/test_data_directory.cc
index b5c4574e6c8..d360628e2fe 100644
--- a/chromium/net/test/test_data_directory.cc
+++ b/chromium/net/test/test_data_directory.cc
@@ -26,7 +26,7 @@ base::FilePath GetTestNetDataDirectory() {
   base::FilePath src_root;
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io_for_path_service;
-    PathService::Get(base::DIR_SOURCE_ROOT, &src_root);
+    base::PathService::Get(base::DIR_SOURCE_ROOT, &src_root);
   }
 
   return src_root.Append(kNetDataRelativePath);
diff --git a/chromium/net/test/test_with_scoped_task_environment.h b/chromium/net/test/test_with_scoped_task_environment.h
new file mode 100644
index 00000000000..4ec5586add4
--- /dev/null
+++ b/chromium/net/test/test_with_scoped_task_environment.h
@@ -0,0 +1,80 @@
+// Copyright 2018 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_TEST_WITH_SCOPED_TASK_ENVIRONMENT_H_
+#define NET_TEST_TEST_WITH_SCOPED_TASK_ENVIRONMENT_H_
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+class TickClock;
+}  // namespace base
+
+namespace net {
+
+// Inherit from this class if a ScopedTaskEnvironment is needed in a test.
+// Use in class hierachies where inheritance from ::testing::Test at the same
+// time is not desirable or possible (for example, when inheriting from
+// PlatformTest at the same time).
+class WithScopedTaskEnvironment {
+ protected:
+  WithScopedTaskEnvironment()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::IO) {}
+  WithScopedTaskEnvironment(
+      base::test::ScopedTaskEnvironment::MainThreadType type)
+      : scoped_task_environment_(type) {}
+
+  bool MainThreadHasPendingTask() const WARN_UNUSED_RESULT {
+    return scoped_task_environment_.MainThreadHasPendingTask();
+  }
+
+  void RunUntilIdle() { scoped_task_environment_.RunUntilIdle(); }
+
+  void FastForwardBy(base::TimeDelta delta) {
+    scoped_task_environment_.FastForwardBy(delta);
+  }
+
+  void FastForwardUntilNoTasksRemain() {
+    scoped_task_environment_.FastForwardUntilNoTasksRemain();
+  }
+
+  const base::TickClock* GetMockTickClock() WARN_UNUSED_RESULT {
+    return scoped_task_environment_.GetMockTickClock();
+  }
+
+  size_t GetPendingMainThreadTaskCount() const WARN_UNUSED_RESULT {
+    return scoped_task_environment_.GetPendingMainThreadTaskCount();
+  }
+
+  base::TimeDelta NextMainThreadPendingTaskDelay() const WARN_UNUSED_RESULT {
+    return scoped_task_environment_.NextMainThreadPendingTaskDelay();
+  }
+
+ private:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+
+  DISALLOW_COPY_AND_ASSIGN(WithScopedTaskEnvironment);
+};
+
+// Inherit from this class instead of ::testing::Test directly if a
+// ScopedTaskEnvironment is needed in a test.
+class TestWithScopedTaskEnvironment : public ::testing::Test,
+                                      public WithScopedTaskEnvironment {
+ protected:
+  TestWithScopedTaskEnvironment() = default;
+  TestWithScopedTaskEnvironment(
+      base::test::ScopedTaskEnvironment::MainThreadType type)
+      : WithScopedTaskEnvironment(type) {}
+
+  DISALLOW_COPY_AND_ASSIGN(TestWithScopedTaskEnvironment);
+};
+
+}  // namespace net
+
+#endif  // NET_TEST_TEST_WITH_SCOPED_TASK_ENVIRONMENT_H_
diff --git a/chromium/net/test/url_request/url_request_failed_job.cc b/chromium/net/test/url_request/url_request_failed_job.cc
index 5417deb68cb..03da26a881f 100644
--- a/chromium/net/test/url_request/url_request_failed_job.cc
+++ b/chromium/net/test/url_request/url_request_failed_job.cc
@@ -122,6 +122,8 @@ void URLRequestFailedJob::PopulateNetErrorDetails(
     NetErrorDetails* details) const {
   if (net_error_ == ERR_QUIC_PROTOCOL_ERROR) {
     details->quic_connection_error = QUIC_INTERNAL_ERROR;
+  } else if (net_error_ == ERR_NETWORK_CHANGED) {
+    details->quic_connection_error = QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK;
   }
 }