BASELINE: Update Chromium to 74.0.3729.159

Change-Id: I8d2497da544c275415aedd94dd25328d555de811
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

27 files changed, 274 insertions, 204 deletions

diff --git a/chromium/net/tools/cert_verify_tool/cert_verify_tool.cc b/chromium/net/tools/cert_verify_tool/cert_verify_tool.cc
index 14c39b02a7d..5129002b4d0 100644
--- a/chromium/net/tools/cert_verify_tool/cert_verify_tool.cc
+++ b/chromium/net/tools/cert_verify_tool/cert_verify_tool.cc
@@ -5,6 +5,7 @@
 #include <iostream>
 
 #include "base/at_exit.h"
+#include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
diff --git a/chromium/net/tools/crash_cache/crash_cache.cc b/chromium/net/tools/crash_cache/crash_cache.cc
index fd7fc910baa..dad16a25547 100644
--- a/chromium/net/tools/crash_cache/crash_cache.cc
+++ b/chromium/net/tools/crash_cache/crash_cache.cc
@@ -49,7 +49,7 @@ int RunSlave(RankCrashes action) {
   base::PathService::Get(base::FILE_EXE, &exe);
 
   base::CommandLine cmdline(exe);
-  cmdline.AppendArg(base::IntToString(action));
+  cmdline.AppendArg(base::NumberToString(action));
 
   base::Process process = base::LaunchProcess(cmdline, base::LaunchOptions());
   if (!process.IsValid()) {
diff --git a/chromium/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc b/chromium/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc
index 40d2d1de0e9..395ab97032e 100644
--- a/chromium/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc
+++ b/chromium/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc
@@ -62,7 +62,7 @@ bool ReadTestCase(const char* filename,
     return false;
   }
 
-  std::unique_ptr<base::Value> value = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> value = base::JSONReader::ReadDeprecated(json);
   if (!value.get()) {
     LOG(ERROR) << filename << ": couldn't parse JSON.";
     return false;
diff --git a/chromium/net/tools/epoll_server/epoll_server.cc b/chromium/net/tools/epoll_server/epoll_server.cc
index 8740b2a5cc3..a686dd7d10d 100644
--- a/chromium/net/tools/epoll_server/epoll_server.cc
+++ b/chromium/net/tools/epoll_server/epoll_server.cc
@@ -462,6 +462,14 @@ void EpollServer::UnregisterAlarm(const AlarmRegToken& iterator_token) {
   cb->OnUnregistration();
 }
 
+EpollServer::AlarmRegToken EpollServer::ReregisterAlarm(
+    EpollServer::AlarmRegToken iterator_token,
+    int64_t timeout_time_in_us) {
+  AlarmCB* cb = iterator_token->second;
+  alarm_map_.erase(iterator_token);
+  return alarm_map_.emplace(timeout_time_in_us, cb);
+}
+
 int EpollServer::NumFDsRegistered() const {
   DCHECK_GE(cb_map_.size(), 1u);
   // Omit the internal FD (read_fd_)
@@ -793,4 +801,9 @@ void EpollAlarm::UnregisterIfRegistered() {
   eps_->UnregisterAlarm(token_);
 }
 
+void EpollAlarm::ReregisterAlarm(int64_t timeout_time_in_us) {
+  DCHECK(registered_);
+  token_ = eps_->ReregisterAlarm(token_, timeout_time_in_us);
+}
+
 }  // namespace net
diff --git a/chromium/net/tools/epoll_server/epoll_server.h b/chromium/net/tools/epoll_server/epoll_server.h
index 97929557953..507c82158cc 100644
--- a/chromium/net/tools/epoll_server/epoll_server.h
+++ b/chromium/net/tools/epoll_server/epoll_server.h
@@ -404,6 +404,10 @@ class EpollServer {
   virtual void UnregisterAlarm(
       const EpollServer::AlarmRegToken& iterator_token);
 
+  virtual EpollServer::AlarmRegToken ReregisterAlarm(
+      EpollServer::AlarmRegToken iterator_token,
+      int64_t timeout_time_in_us);
+
   ////////////////////////////////////////
 
   // Summary:
@@ -475,12 +479,15 @@ class EpollServer {
 
   // Summary:
   //   Accessor for the current value of timeout_in_us.
-  int timeout_in_us() const { return timeout_in_us_; }
+  int timeout_in_us_for_test() const { return timeout_in_us_; }
 
   // Summary:
   // Returns true when the EpollServer() is being destroyed.
   bool in_shutdown() const { return in_shutdown_; }
 
+  // Compatibility stub.
+  void Shutdown() {}
+
  protected:
   virtual void SetNonblocking(int fd);
 
@@ -1033,6 +1040,9 @@ class EpollAlarm : public EpollAlarmCallbackInterface {
   // If the alarm was registered, unregister it.
   void UnregisterIfRegistered();
 
+  // Reregisters the alarm at specified time.
+  void ReregisterAlarm(int64_t timeout_time_in_us);
+
   bool registered() const { return registered_; }
 
   const EpollServer* eps() const { return eps_; }
diff --git a/chromium/net/tools/epoll_server/fake_epoll_server.cc b/chromium/net/tools/epoll_server/fake_epoll_server.cc
new file mode 100644
index 00000000000..e5ab48c52bf
--- /dev/null
+++ b/chromium/net/tools/epoll_server/fake_epoll_server.cc
@@ -0,0 +1,60 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/tools/epoll_server/fake_epoll_server.h"
+
+namespace quic {
+namespace test {
+
+FakeTimeEpollServer::FakeTimeEpollServer() : now_in_usec_(0) {}
+
+FakeTimeEpollServer::~FakeTimeEpollServer() = default;
+
+int64_t FakeTimeEpollServer::NowInUsec() const {
+  return now_in_usec_;
+}
+
+FakeEpollServer::FakeEpollServer() : until_in_usec_(-1) {}
+
+FakeEpollServer::~FakeEpollServer() = default;
+
+int FakeEpollServer::epoll_wait_impl(int epfd,
+                                     struct epoll_event* events,
+                                     int max_events,
+                                     int timeout_in_ms) {
+  int num_events = 0;
+  while (!event_queue_.empty() && num_events < max_events &&
+         event_queue_.begin()->first <= NowInUsec() &&
+         ((until_in_usec_ == -1) ||
+          (event_queue_.begin()->first < until_in_usec_))) {
+    int64_t event_time_in_usec = event_queue_.begin()->first;
+    events[num_events] = event_queue_.begin()->second;
+    if (event_time_in_usec > NowInUsec()) {
+      set_now_in_usec(event_time_in_usec);
+    }
+    event_queue_.erase(event_queue_.begin());
+    ++num_events;
+  }
+  if (num_events == 0) {       // then we'd have waited 'till the timeout.
+    if (until_in_usec_ < 0) {  // then we don't care what the final time is.
+      if (timeout_in_ms > 0) {
+        AdvanceBy(timeout_in_ms * 1000);
+      }
+    } else {  // except we assume that we don't wait for the timeout
+      // period if until_in_usec_ is a positive number.
+      set_now_in_usec(until_in_usec_);
+      // And reset until_in_usec_ to signal no waiting (as
+      // the AdvanceByExactly* stuff is meant to be one-shot,
+      // as are all similar net::EpollServer functions)
+      until_in_usec_ = -1;
+    }
+  }
+  if (until_in_usec_ >= 0) {
+    CHECK(until_in_usec_ >= NowInUsec());
+  }
+  return num_events;
+}
+
+}  // namespace test
+}  // namespace quic
diff --git a/chromium/net/tools/epoll_server/fake_epoll_server.h b/chromium/net/tools/epoll_server/fake_epoll_server.h
new file mode 100644
index 00000000000..8605c43f8f7
--- /dev/null
+++ b/chromium/net/tools/epoll_server/fake_epoll_server.h
@@ -0,0 +1,115 @@
+// 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.
+
+#ifndef NET_TOOLS_EPOLL_SERVER_FAKE_EPOLL_SERVER_H_
+#define NET_TOOLS_EPOLL_SERVER_FAKE_EPOLL_SERVER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "net/tools/epoll_server/epoll_server.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace quic {
+namespace test {
+
+// Unlike the full FakeEpollServer, this only lies about the time but lets
+// fd events operate normally.  Usefully when interacting with real backends
+// but wanting to skip forward in time to trigger timeouts.
+class FakeTimeEpollServer : public net::EpollServer {
+ public:
+  FakeTimeEpollServer();
+  ~FakeTimeEpollServer() override;
+
+  // Replaces the net::EpollServer NowInUsec.
+  int64_t NowInUsec() const override;
+
+  void set_now_in_usec(int64_t nius) { now_in_usec_ = nius; }
+
+  // Advances the virtual 'now' by advancement_usec.
+  void AdvanceBy(int64_t advancement_usec) {
+    set_now_in_usec(NowInUsec() + advancement_usec);
+  }
+
+  // Advances the virtual 'now' by advancement_usec, and
+  // calls WaitForEventAndExecteCallbacks.
+  // Note that the WaitForEventsAndExecuteCallbacks invocation
+  // may cause NowInUs to advance beyond what was specified here.
+  // If that is not desired, use the AdvanceByExactly calls.
+  void AdvanceByAndWaitForEventsAndExecuteCallbacks(int64_t advancement_usec) {
+    AdvanceBy(advancement_usec);
+    WaitForEventsAndExecuteCallbacks();
+  }
+
+ private:
+  int64_t now_in_usec_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeTimeEpollServer);
+};
+
+class FakeEpollServer : public FakeTimeEpollServer {
+ public:  // type definitions
+  using EventQueue = std::unordered_multimap<int64_t, struct epoll_event>;
+
+  FakeEpollServer();
+  ~FakeEpollServer() override;
+
+  // time_in_usec is the time at which the event specified
+  // by 'ee' will be delivered. Note that it -is- possible
+  // to add an event for a time which has already been passed..
+  // .. upon the next time that the callbacks are invoked,
+  // all events which are in the 'past' will be delivered.
+  void AddEvent(int64_t time_in_usec, const struct epoll_event& ee) {
+    event_queue_.insert(std::make_pair(time_in_usec, ee));
+  }
+
+  // Advances the virtual 'now' by advancement_usec,
+  // and ensure that the next invocation of
+  // WaitForEventsAndExecuteCallbacks goes no farther than
+  // advancement_usec from the current time.
+  void AdvanceByExactly(int64_t advancement_usec) {
+    until_in_usec_ = NowInUsec() + advancement_usec;
+    set_now_in_usec(NowInUsec() + advancement_usec);
+  }
+
+  // As above, except calls WaitForEventsAndExecuteCallbacks.
+  void AdvanceByExactlyAndCallCallbacks(int64_t advancement_usec) {
+    AdvanceByExactly(advancement_usec);
+    WaitForEventsAndExecuteCallbacks();
+  }
+
+  std::unordered_set<AlarmCB*>::size_type NumberOfAlarms() const {
+    return all_alarms_.size();
+  }
+
+ protected:  // functions
+  // These functions do nothing here, as we're not actually
+  // using the epoll_* syscalls.
+  void DelFD(int fd) const override {}
+  void AddFD(int fd, int event_mask) const override {}
+  void ModFD(int fd, int event_mask) const override {}
+
+  // Replaces the epoll_server's epoll_wait_impl.
+  int epoll_wait_impl(int epfd,
+                      struct epoll_event* events,
+                      int max_events,
+                      int timeout_in_ms) override;
+  void SetNonblocking(int fd) override {}
+
+ private:  // members
+  EventQueue event_queue_;
+  int64_t until_in_usec_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeEpollServer);
+};
+
+}  // namespace test
+}  // namespace quic
+
+#endif  // NET_TOOLS_EPOLL_SERVER_FAKE_EPOLL_SERVER_H_
diff --git a/chromium/net/tools/quic/quic_http_proxy_backend.cc b/chromium/net/tools/quic/quic_http_proxy_backend.cc
index 8ce6629d817..4471240cebb 100644
--- a/chromium/net/tools/quic/quic_http_proxy_backend.cc
+++ b/chromium/net/tools/quic/quic_http_proxy_backend.cc
@@ -13,6 +13,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/bind.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
diff --git a/chromium/net/tools/quic/quic_http_proxy_backend_stream.h b/chromium/net/tools/quic/quic_http_proxy_backend_stream.h
index a64a1cc351b..d415fadd43a 100644
--- a/chromium/net/tools/quic/quic_http_proxy_backend_stream.h
+++ b/chromium/net/tools/quic/quic_http_proxy_backend_stream.h
@@ -55,9 +55,12 @@ class UploadDataStream;
 class QuicHttpProxyBackend;
 
 // An adapter for making HTTP requests to net::URLRequest.
+//
+// TODO(https://crbug.com/937621):  This class does not appear to be thread
+// safe, so all its tests are disabled.
 class QuicHttpProxyBackendStream : public net::URLRequest::Delegate {
  public:
-  QuicHttpProxyBackendStream(QuicHttpProxyBackend* context);
+  explicit QuicHttpProxyBackendStream(QuicHttpProxyBackend* context);
   ~QuicHttpProxyBackendStream() override;
 
   static const std::set<std::string> kHopHeaders;
diff --git a/chromium/net/tools/quic/quic_http_proxy_backend_stream_test.cc b/chromium/net/tools/quic/quic_http_proxy_backend_stream_test.cc
index b0e4372e588..76cdaf2251f 100644
--- a/chromium/net/tools/quic/quic_http_proxy_backend_stream_test.cc
+++ b/chromium/net/tools/quic/quic_http_proxy_backend_stream_test.cc
@@ -195,7 +195,8 @@ class QuicHttpProxyBackendStreamTest : public QuicTest {
   std::unique_ptr<EmbeddedTestServer> test_server_;
 };
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendGetDefault) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendGetDefault) {
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = kDefaultResponsePath;
   request_headers[":authority"] = "www.example.org";
@@ -214,7 +215,7 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendGetDefault) {
   EXPECT_EQ(kDefaultResponseBody, quic_response->body());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendGetLarge) {
+TEST_F(QuicHttpProxyBackendStreamTest, DISABLED_SendRequestToBackendGetLarge) {
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/defaultresponselarge";
   request_headers[":authority"] = "www.example.org";
@@ -235,7 +236,7 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendGetLarge) {
   EXPECT_EQ(kLargeResponseBody, quic_response->body());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostBody) {
+TEST_F(QuicHttpProxyBackendStreamTest, DISABLED_SendRequestToBackendPostBody) {
   const char kUploadData[] = "bobsyeruncle";
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/echo";
@@ -258,7 +259,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostBody) {
   EXPECT_EQ(kUploadData, quic_response->body());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostEmptyString) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendPostEmptyString) {
   const char kUploadData[] = "";
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/echo";
@@ -281,7 +283,7 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostEmptyString) {
   EXPECT_EQ(kUploadData, quic_response->body());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostFile) {
+TEST_F(QuicHttpProxyBackendStreamTest, DISABLED_SendRequestToBackendPostFile) {
   std::string kUploadData;
   base::FilePath upload_path = GetUploadFileTestPath();
   ASSERT_TRUE(base::ReadFileToString(upload_path, &kUploadData));
@@ -306,7 +308,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendPostFile) {
   EXPECT_EQ(kUploadData, quic_response->body());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendResponse500) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendResponse500) {
   const char kUploadData[] = "bobsyeruncle";
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/echo?status=500";
@@ -326,7 +329,7 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendResponse500) {
   EXPECT_EQ(500, ParseHeaderStatusCode(quic_response->headers()));
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendFail) {
+TEST_F(QuicHttpProxyBackendStreamTest, DISABLED_SendRequestToBackendFail) {
   const char kUploadData[] = "bobsyeruncle";
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/echo";
@@ -345,7 +348,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendFail) {
             quic_response->response_type());
 }
 
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendOnRedirect) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendOnRedirect) {
   const std::string kRedirectTarget = backend_url_.append("/echo");
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = std::string("/server-redirect?") + kRedirectTarget;
@@ -367,7 +371,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendOnRedirect) {
 
 // Ensure that the proxy rewrites the content-length when receiving a Gzipped
 // response
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendHandleGzip) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendHandleGzip) {
   const char kGzipData[] =
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!!";
   uint64_t rawBodyLength = strlen(kGzipData);
@@ -406,7 +411,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendHandleGzip) {
 }
 
 // Ensure cookies are not saved/updated at the proxy
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendCookiesNotSaved) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendCookiesNotSaved) {
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":authority"] = "www.example.org";
   request_headers[":method"] = "GET";
@@ -450,7 +456,8 @@ TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendCookiesNotSaved) {
 
 // Ensure hop-by-hop headers are removed from the request and response to the
 // backend
-TEST_F(QuicHttpProxyBackendStreamTest, SendRequestToBackendHopHeaders) {
+TEST_F(QuicHttpProxyBackendStreamTest,
+       DISABLED_SendRequestToBackendHopHeaders) {
   spdy::SpdyHeaderBlock request_headers;
   request_headers[":path"] = "/echoall";
   request_headers[":authority"] = "www.example.org";
diff --git a/chromium/net/tools/quic/quic_http_proxy_backend_test.cc b/chromium/net/tools/quic/quic_http_proxy_backend_test.cc
index 691f304ba4e..c1b3a3c9d7c 100644
--- a/chromium/net/tools/quic/quic_http_proxy_backend_test.cc
+++ b/chromium/net/tools/quic/quic_http_proxy_backend_test.cc
@@ -26,9 +26,9 @@ class TestQuicServerStream
 
   quic::QuicConnectionId connection_id() const override {
     return quic::test::TestConnectionId(123);
-  };
-  quic::QuicStreamId stream_id() const override { return 5; };
-  std::string peer_host() const override { return "127.0.0.1"; };
+  }
+  quic::QuicStreamId stream_id() const override { return 5; }
+  std::string peer_host() const override { return "127.0.0.1"; }
 
   void OnResponseBackendComplete(
       const quic::QuicBackendResponse* response,
diff --git a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc
deleted file mode 100644
index d57af46aeaa..00000000000
--- a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2014 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/tools/quic/quic_simple_per_connection_packet_writer.h"
-
-#include "base/bind.h"
-#include "net/tools/quic/quic_simple_server_packet_writer.h"
-
-namespace net {
-
-QuicSimplePerConnectionPacketWriter::QuicSimplePerConnectionPacketWriter(
-    QuicSimpleServerPacketWriter* shared_writer)
-    : shared_writer_(shared_writer),
-      connection_(nullptr),
-      weak_factory_(this) {}
-
-QuicSimplePerConnectionPacketWriter::~QuicSimplePerConnectionPacketWriter() =
-    default;
-
-quic::QuicPacketWriter* QuicSimplePerConnectionPacketWriter::shared_writer()
-    const {
-  return shared_writer_;
-}
-
-quic::WriteResult QuicSimplePerConnectionPacketWriter::WritePacket(
-    const char* buffer,
-    size_t buf_len,
-    const quic::QuicIpAddress& self_address,
-    const quic::QuicSocketAddress& peer_address,
-    quic::PerPacketOptions* options) {
-  return shared_writer_->WritePacketWithCallback(
-      buffer, buf_len, self_address, peer_address, options,
-      base::Bind(&QuicSimplePerConnectionPacketWriter::OnWriteComplete,
-                 weak_factory_.GetWeakPtr()));
-}
-
-bool QuicSimplePerConnectionPacketWriter::IsWriteBlockedDataBuffered() const {
-  return shared_writer_->IsWriteBlockedDataBuffered();
-}
-
-bool QuicSimplePerConnectionPacketWriter::IsWriteBlocked() const {
-  return shared_writer_->IsWriteBlocked();
-}
-
-void QuicSimplePerConnectionPacketWriter::SetWritable() {
-  shared_writer_->SetWritable();
-}
-
-void QuicSimplePerConnectionPacketWriter::OnWriteComplete(
-    quic::WriteResult result) {
-  if (connection_ && result.status == quic::WRITE_STATUS_ERROR) {
-    connection_->OnWriteError(result.error_code);
-  }
-}
-
-quic::QuicByteCount QuicSimplePerConnectionPacketWriter::GetMaxPacketSize(
-    const quic::QuicSocketAddress& peer_address) const {
-  return shared_writer_->GetMaxPacketSize(peer_address);
-}
-
-}  // namespace net
diff --git a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h
deleted file mode 100644
index 08d615b15be..00000000000
--- a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2014 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_TOOLS_QUIC_QUIC_SIMPLE_PER_CONNECTION_PACKET_WRITER_H_
-#define NET_TOOLS_QUIC_QUIC_SIMPLE_PER_CONNECTION_PACKET_WRITER_H_
-
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "net/third_party/quic/core/quic_connection.h"
-#include "net/third_party/quic/core/quic_packet_writer.h"
-
-namespace net {
-
-class QuicSimpleServerPacketWriter;
-
-// A connection-specific packet writer that notifies its connection when its
-// writes to the shared QuicServerPacketWriter complete.
-// This class is necessary because multiple connections can share the same
-// QuicServerPacketWriter, so it has no way to know which connection to notify.
-class QuicSimplePerConnectionPacketWriter : public quic::QuicPacketWriter {
- public:
-  // Does not take ownership of |shared_writer| or |connection|.
-  QuicSimplePerConnectionPacketWriter(
-      QuicSimpleServerPacketWriter* shared_writer);
-  ~QuicSimplePerConnectionPacketWriter() override;
-
-  quic::QuicPacketWriter* shared_writer() const;
-  void set_connection(quic::QuicConnection* connection) {
-    connection_ = connection;
-  }
-  quic::QuicConnection* connection() const { return connection_; }
-
-  // Default implementation of the quic::QuicPacketWriter interface: Passes
-  // everything to |shared_writer_|.
-  quic::WriteResult WritePacket(const char* buffer,
-                                size_t buf_len,
-                                const quic::QuicIpAddress& self_address,
-                                const quic::QuicSocketAddress& peer_address,
-                                quic::PerPacketOptions* options) override;
-  bool IsWriteBlockedDataBuffered() const override;
-  bool IsWriteBlocked() const override;
-  void SetWritable() override;
-  quic::QuicByteCount GetMaxPacketSize(
-      const quic::QuicSocketAddress& peer_address) const override;
-
- private:
-  void OnWriteComplete(quic::WriteResult result);
-
-  QuicSimpleServerPacketWriter* shared_writer_;  // Not owned.
-  quic::QuicConnection* connection_;             // Not owned.
-
-  base::WeakPtrFactory<QuicSimplePerConnectionPacketWriter> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(QuicSimplePerConnectionPacketWriter);
-};
-
-}  // namespace net
-
-#endif  // NET_TOOLS_QUIC_QUIC_SIMPLE_PER_CONNECTION_PACKET_WRITER_H_
diff --git a/chromium/net/tools/quic/quic_simple_server.cc b/chromium/net/tools/quic/quic_simple_server.cc
index 327fd42299c..1ba1ed60310 100644
--- a/chromium/net/tools/quic/quic_simple_server.cc
+++ b/chromium/net/tools/quic/quic_simple_server.cc
@@ -6,6 +6,7 @@
 
 #include <string.h>
 
+#include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -20,7 +21,6 @@
 #include "net/third_party/quic/core/quic_packets.h"
 #include "net/third_party/quic/core/tls_server_handshaker.h"
 #include "net/third_party/quic/tools/quic_simple_dispatcher.h"
-#include "net/tools/quic/quic_simple_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_session_helper.h"
 
@@ -132,7 +132,7 @@ int QuicSimpleServer::Listen(const IPEndPoint& address) {
   socket_.swap(socket);
 
   dispatcher_.reset(new quic::QuicSimpleDispatcher(
-      config_, &crypto_config_, &version_manager_,
+      &config_, &crypto_config_, &version_manager_,
       std::unique_ptr<quic::QuicConnectionHelperInterface>(helper_),
       std::unique_ptr<quic::QuicCryptoServerStream::Helper>(
           new QuicSimpleServerSessionHelper(quic::QuicRandom::GetInstance())),
@@ -179,8 +179,8 @@ void QuicSimpleServer::StartReading() {
     if (dispatcher_->HasChlosBuffered()) {
       // No more packets to read, so yield before processing buffered packets.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&QuicSimpleServer::StartReading,
-                                weak_factory_.GetWeakPtr()));
+          FROM_HERE, base::BindOnce(&QuicSimpleServer::StartReading,
+                                    weak_factory_.GetWeakPtr()));
     }
     return;
   }
@@ -190,8 +190,8 @@ void QuicSimpleServer::StartReading() {
     // Schedule the processing through the message loop to 1) prevent infinite
     // recursion and 2) avoid blocking the thread for too long.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&QuicSimpleServer::OnReadComplete,
-                              weak_factory_.GetWeakPtr(), result));
+        FROM_HERE, base::BindOnce(&QuicSimpleServer::OnReadComplete,
+                                  weak_factory_.GetWeakPtr(), result));
   } else {
     OnReadComplete(result);
   }
diff --git a/chromium/net/tools/quic/quic_simple_server_packet_writer.cc b/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
index c8cfb44f547..796a5b2c3e8 100644
--- a/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
+++ b/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
@@ -4,6 +4,7 @@
 
 #include "net/tools/quic/quic_simple_server_packet_writer.h"
 
+#include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ -25,23 +26,6 @@ QuicSimpleServerPacketWriter::QuicSimpleServerPacketWriter(
 
 QuicSimpleServerPacketWriter::~QuicSimpleServerPacketWriter() = default;
 
-quic::WriteResult QuicSimpleServerPacketWriter::WritePacketWithCallback(
-    const char* buffer,
-    size_t buf_len,
-    const quic::QuicIpAddress& self_address,
-    const quic::QuicSocketAddress& peer_address,
-    quic::PerPacketOptions* options,
-    WriteCallback callback) {
-  DCHECK(callback_.is_null());
-  callback_ = callback;
-  quic::WriteResult result =
-      WritePacket(buffer, buf_len, self_address, peer_address, options);
-  if (!quic::IsWriteBlockedStatus(result.status)) {
-    callback_.Reset();
-  }
-  return result;
-}
-
 void QuicSimpleServerPacketWriter::OnWriteComplete(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   write_blocked_ = false;
@@ -53,11 +37,6 @@ void QuicSimpleServerPacketWriter::OnWriteComplete(int rv) {
   dispatcher_->OnCanWrite();
 }
 
-bool QuicSimpleServerPacketWriter::IsWriteBlockedDataBuffered() const {
-  // UDPServerSocket::SendTo buffers the data until the Write is permitted.
-  return true;
-}
-
 bool QuicSimpleServerPacketWriter::IsWriteBlocked() const {
   return write_blocked_;
 }
diff --git a/chromium/net/tools/quic/quic_simple_server_packet_writer.h b/chromium/net/tools/quic/quic_simple_server_packet_writer.h
index 1ff99885e08..ee6a4b75d5b 100644
--- a/chromium/net/tools/quic/quic_simple_server_packet_writer.h
+++ b/chromium/net/tools/quic/quic_simple_server_packet_writer.h
@@ -35,15 +35,6 @@ class QuicSimpleServerPacketWriter : public quic::QuicPacketWriter {
                                quic::QuicDispatcher* dispatcher);
   ~QuicSimpleServerPacketWriter() override;
 
-  // Wraps WritePacket, and ensures that |callback| is run on successful write.
-  quic::WriteResult WritePacketWithCallback(
-      const char* buffer,
-      size_t buf_len,
-      const quic::QuicIpAddress& self_address,
-      const quic::QuicSocketAddress& peer_address,
-      quic::PerPacketOptions* options,
-      WriteCallback callback);
-
   quic::WriteResult WritePacket(const char* buffer,
                                 size_t buf_len,
                                 const quic::QuicIpAddress& self_address,
@@ -53,7 +44,6 @@ class QuicSimpleServerPacketWriter : public quic::QuicPacketWriter {
   void OnWriteComplete(int rv);
 
   // quic::QuicPacketWriter implementation:
-  bool IsWriteBlockedDataBuffered() const override;
   bool IsWriteBlocked() const override;
   void SetWritable() override;
   quic::QuicByteCount GetMaxPacketSize(
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper.cc b/chromium/net/tools/quic/quic_simple_server_session_helper.cc
index cb35d10bec9..c2117f1823f 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper.cc
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper.cc
@@ -16,6 +16,7 @@ QuicSimpleServerSessionHelper::~QuicSimpleServerSessionHelper() = default;
 
 quic::QuicConnectionId
 QuicSimpleServerSessionHelper::GenerateConnectionIdForReject(
+    quic::QuicTransportVersion /*version*/,
     quic::QuicConnectionId /*connection_id*/) const {
   return quic::QuicUtils::CreateRandomConnectionId(random_);
 }
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper.h b/chromium/net/tools/quic/quic_simple_server_session_helper.h
index 46f3b6597e2..cbb425c8ba1 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper.h
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper.h
@@ -20,6 +20,7 @@ class QuicSimpleServerSessionHelper
   ~QuicSimpleServerSessionHelper() override;
 
   quic::QuicConnectionId GenerateConnectionIdForReject(
+      quic::QuicTransportVersion /*version*/,
       quic::QuicConnectionId /*connection_id*/) const override;
 
   bool CanAcceptClientHello(const quic::CryptoHandshakeMessage& message,
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc b/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
index a9c8e16bd58..5b75791ebdc 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
@@ -16,9 +16,10 @@ TEST(QuicSimpleCryptoServerStreamHelperTest, GenerateConnectionIdForReject) {
   quic::test::MockRandom random;
   quic::QuicSimpleCryptoServerStreamHelper helper(&random);
 
-  EXPECT_EQ(
-      quic::QuicUtils::CreateRandomConnectionId(&random),
-      helper.GenerateConnectionIdForReject(quic::test::TestConnectionId(42)));
+  EXPECT_EQ(quic::QuicUtils::CreateRandomConnectionId(&random),
+            // N.B., version number and ID are ignored in the helper.
+            helper.GenerateConnectionIdForReject(
+                quic::QUIC_VERSION_46, quic::test::TestConnectionId(42)));
 }
 
 }  // namespace net
diff --git a/chromium/net/tools/quic/quic_simple_server_test.cc b/chromium/net/tools/quic/quic_simple_server_test.cc
index 0df75865dd4..eb673e3d90d 100644
--- a/chromium/net/tools/quic/quic_simple_server_test.cc
+++ b/chromium/net/tools/quic/quic_simple_server_test.cc
@@ -32,7 +32,7 @@ class QuicChromeServerDispatchPacketTest : public QuicTest {
                        quic::KeyExchangeSource::Default(),
                        quic::TlsServerHandshaker::CreateSslCtx()),
         version_manager_(quic::AllSupportedVersions()),
-        dispatcher_(config_,
+        dispatcher_(&config_,
                     &crypto_config_,
                     &version_manager_,
                     std::unique_ptr<quic::test::MockQuicConnectionHelper>(
diff --git a/chromium/net/tools/quic/synchronous_host_resolver.cc b/chromium/net/tools/quic/synchronous_host_resolver.cc
index 75a21add12b..32f670e3b3a 100644
--- a/chromium/net/tools/quic/synchronous_host_resolver.cc
+++ b/chromium/net/tools/quic/synchronous_host_resolver.cc
@@ -4,11 +4,16 @@
 
 #include "net/tools/quic/synchronous_host_resolver.h"
 
+#include <memory>
+#include <utility>
+
 #include "base/at_exit.h"
+#include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/simple_thread.h"
@@ -61,20 +66,24 @@ void ResolverThread::Run() {
   std::unique_ptr<net::HostResolverImpl> resolver(
       new net::HostResolverImpl(options, &net_log));
 
-  std::unique_ptr<net::HostResolver::Request> request;
   HostPortPair host_port_pair(host_, 80);
-  base::RunLoop run_loop;
-  rv_ = resolver->Resolve(
-      HostResolver::RequestInfo(host_port_pair), DEFAULT_PRIORITY, addresses_,
-      base::Bind(&ResolverThread::OnResolutionComplete, base::Unretained(this),
-                 run_loop.QuitClosure()),
-      &request, NetLogWithSource());
+  std::unique_ptr<net::HostResolver::ResolveHostRequest> request =
+      resolver->CreateRequest(host_port_pair, NetLogWithSource(),
+                              base::nullopt);
 
-  if (rv_ != ERR_IO_PENDING)
-    return;
-
-  // Run the mesage loop until OnResolutionComplete quits it.
-  run_loop.Run();
+  base::RunLoop run_loop;
+  rv_ = request->Start(base::BindOnce(&ResolverThread::OnResolutionComplete,
+                                      base::Unretained(this),
+                                      run_loop.QuitClosure()));
+
+  if (rv_ == ERR_IO_PENDING) {
+    // Run the message loop until OnResolutionComplete quits it.
+    run_loop.Run();
+  }
+
+  if (rv_ == OK) {
+    *addresses_ = request->GetAddressResults().value();
+  }
 }
 
 int ResolverThread::Resolve(const std::string& host, AddressList* addresses) {
diff --git a/chromium/net/tools/quic/synchronous_host_resolver.h b/chromium/net/tools/quic/synchronous_host_resolver.h
index 0b8777439d3..89b15a2f31d 100644
--- a/chromium/net/tools/quic/synchronous_host_resolver.h
+++ b/chromium/net/tools/quic/synchronous_host_resolver.h
@@ -7,6 +7,8 @@
 #ifndef NET_TOOLS_QUIC_SYNCHRONOUS_HOST_RESOLVER_H_
 #define NET_TOOLS_QUIC_SYNCHRONOUS_HOST_RESOLVER_H_
 
+#include <string>
+
 #include "net/base/address_list.h"
 #include "net/dns/host_resolver.h"
 
diff --git a/chromium/net/tools/stress_cache/stress_cache.cc b/chromium/net/tools/stress_cache/stress_cache.cc
index 76446e48774..2483cebeefb 100644
--- a/chromium/net/tools/stress_cache/stress_cache.cc
+++ b/chromium/net/tools/stress_cache/stress_cache.cc
@@ -61,7 +61,7 @@ int RunSlave(int iteration) {
   base::PathService::Get(base::FILE_EXE, &exe);
 
   base::CommandLine cmdline(exe);
-  cmdline.AppendArg(base::IntToString(iteration));
+  cmdline.AppendArg(base::NumberToString(iteration));
 
   base::Process process = base::LaunchProcess(cmdline, base::LaunchOptions());
   if (!process.IsValid()) {
@@ -269,7 +269,7 @@ void EntryWrapper::DoIdle() {
   g_data->pendig_operations--;
   DCHECK(g_data->pendig_operations);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(&LoopTask));
+                                                base::BindOnce(&LoopTask));
 }
 
 // The task that keeps the main thread busy. Whenever an entry becomes idle this
@@ -290,7 +290,7 @@ void LoopTask() {
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(&LoopTask));
+                                                base::BindOnce(&LoopTask));
 }
 
 // This thread will loop forever, adding and removing entries from the cache.
@@ -333,7 +333,7 @@ void StressTheCache(int iteration) {
     g_data->keys[i] = GenerateStressKey();
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(&LoopTask));
+                                                base::BindOnce(&LoopTask));
   base::RunLoop().Run();
 }
 
@@ -361,7 +361,7 @@ void CrashCallback() {
 
 void RunSoon(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   const base::TimeDelta kTaskDelay = base::TimeDelta::FromSeconds(10);
-  task_runner->PostDelayedTask(FROM_HERE, base::Bind(&CrashCallback),
+  task_runner->PostDelayedTask(FROM_HERE, base::BindOnce(&CrashCallback),
                                kTaskDelay);
 }
 
diff --git a/chromium/net/tools/tld_cleanup/tld_cleanup_util.cc b/chromium/net/tools/tld_cleanup/tld_cleanup_util.cc
index bf177ca1203..ba870b4ac42 100644
--- a/chromium/net/tools/tld_cleanup/tld_cleanup_util.cc
+++ b/chromium/net/tools/tld_cleanup/tld_cleanup_util.cc
@@ -56,7 +56,7 @@ bool WriteRules(const RuleMap& rules, const base::FilePath& outfile) {
     if (i->second.is_private) {
       type += kPrivateRule;
     }
-    data.append(base::IntToString(type));
+    data.append(base::NumberToString(type));
     data.append("\n");
   }
 
diff --git a/chromium/net/tools/transport_security_state_generator/input_file_parsers.cc b/chromium/net/tools/transport_security_state_generator/input_file_parsers.cc
index 1046ff67421..3da453f3a52 100644
--- a/chromium/net/tools/transport_security_state_generator/input_file_parsers.cc
+++ b/chromium/net/tools/transport_security_state_generator/input_file_parsers.cc
@@ -310,7 +310,7 @@ bool ParseJSON(base::StringPiece json,
       "test",        "public-suffix", "google",      "custom",
       "bulk-legacy", "bulk-18-weeks", "bulk-1-year", "public-suffix-requested"};
 
-  std::unique_ptr<base::Value> value = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> value = base::JSONReader::ReadDeprecated(json);
   base::DictionaryValue* dict_value = nullptr;
   if (!value.get() || !value->GetAsDictionary(&dict_value)) {
     LOG(ERROR) << "Could not parse the input JSON file";
diff --git a/chromium/net/tools/transport_security_state_generator/spki_hash.h b/chromium/net/tools/transport_security_state_generator/spki_hash.h
index 20de8fecc8a..cf0ed1cea37 100644
--- a/chromium/net/tools/transport_security_state_generator/spki_hash.h
+++ b/chromium/net/tools/transport_security_state_generator/spki_hash.h
@@ -37,7 +37,7 @@ class SPKIHash {
   size_t size() const { return kLength; }
 
   uint8_t* data() { return data_; }
-  const uint8_t* data() const { return data_; };
+  const uint8_t* data() const { return data_; }
 
  private:
   // The bytes of the hash. Current hashes are SHA256 and thus 32 bytes long.
diff --git a/chromium/net/tools/update_ios_bundle_data.py b/chromium/net/tools/update_ios_bundle_data.py
index e6b8ad577e3..144655c3005 100755
--- a/chromium/net/tools/update_ios_bundle_data.py
+++ b/chromium/net/tools/update_ios_bundle_data.py
@@ -51,6 +51,7 @@ net_unittest_bundle_data_globs = [
     "data/parse_certificate_unittest/*.pem",
     "data/parse_certificate_unittest/*.pk8",
     "data/test.html",
+    "data/trial_comparison_cert_verifier_unittest/**/*.pem",
     "data/url_request_unittest/*",
     "data/verify_certificate_chain_unittest/**/*.pem",
     "data/verify_certificate_chain_unittest/**/*.test",