BASELINE: Update Chromium to 96.0.4664.181

Change-Id: I762cd1da89d73aa6313b4a753fe126c34833f046 Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
author: Allan Sandfeld Jensen <allan.jensen@qt.io> 2022-02-02 12:21:57 +0100
committer: Allan Sandfeld Jensen <allan.jensen@qt.io> 2022-02-12 08:13:00 +0000
commit: 606d85f2a5386472314d39923da28c70c60dc8e7 (patch)
tree: a8f4d7bf997f349f45605e6058259fba0630e4d7 /chromium/net/socket
parent: 5786336dda477d04fb98483dca1a5426eebde2d7 (diff)
download: qtwebengine-chromium-606d85f2a5386472314d39923da28c70c60dc8e7.tar.gz
83 files changed, 836 insertions, 729 deletions
diff --git a/chromium/net/socket/client_socket_handle.cc b/chromium/net/socket/client_socket_handle.cc
index d9b84c75759..8de84106704 100644
--- a/chromium/net/socket/client_socket_handle.cc
+++ b/chromium/net/socket/client_socket_handle.cc
@@ -152,13 +152,6 @@ bool ClientSocketHandle::GetLoadTimingInfo(
   return true;
 }
 
-void ClientSocketHandle::DumpMemoryStats(
-    StreamSocket::SocketMemoryStats* stats) const {
-  if (!socket_)
-    return;
-  socket_->DumpMemoryStats(stats);
-}
-
 void ClientSocketHandle::SetSocket(std::unique_ptr<StreamSocket> s) {
   socket_ = std::move(s);
 }
diff --git a/chromium/net/socket/client_socket_handle.h b/chromium/net/socket/client_socket_handle.h
index 2e41eba29f6..61ab4a880ce 100644
--- a/chromium/net/socket/client_socket_handle.h
+++ b/chromium/net/socket/client_socket_handle.h
@@ -50,6 +50,10 @@ class NET_EXPORT ClientSocketHandle {
   };
 
   ClientSocketHandle();
+
+  ClientSocketHandle(const ClientSocketHandle&) = delete;
+  ClientSocketHandle& operator=(const ClientSocketHandle&) = delete;
+
   ~ClientSocketHandle();
 
   // Initializes a ClientSocketHandle object, which involves talking to the
@@ -144,11 +148,6 @@ class NET_EXPORT ClientSocketHandle {
   bool GetLoadTimingInfo(bool is_reused,
                          LoadTimingInfo* load_timing_info) const;
 
-  // Dumps memory allocation stats into |stats|. |stats| can be assumed as being
-  // default initialized upon entry. Implementation overrides fields in
-  // |stats|.
-  void DumpMemoryStats(StreamSocket::SocketMemoryStats* stats) const;
-
   // Used by ClientSocketPool to initialize the ClientSocketHandle.
   //
   // SetSocket() may also be used if this handle is used as simply for
@@ -250,8 +249,6 @@ class NET_EXPORT ClientSocketHandle {
 
   // Timing information is set when a connection is successfully established.
   LoadTimingInfo::ConnectTiming connect_timing_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSocketHandle);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/client_socket_pool.cc b/chromium/net/socket/client_socket_pool.cc
index f3ec46ff9b0..d56a35c79a8 100644
--- a/chromium/net/socket/client_socket_pool.cc
+++ b/chromium/net/socket/client_socket_pool.cc
@@ -133,7 +133,7 @@ ClientSocketPool::~ClientSocketPool() = default;
 
 // static
 base::TimeDelta ClientSocketPool::used_idle_socket_timeout() {
-  return base::TimeDelta::FromSeconds(g_used_idle_socket_timeout_s);
+  return base::Seconds(g_used_idle_socket_timeout_s);
 }
 
 // static
@@ -200,10 +200,8 @@ std::unique_ptr<ConnectJob> ClientSocketPool::CreateConnectJob(
         is_for_websockets_);
   }
 
-  // TODO(crbug.com/1206799): Pass along as SchemeHostPort.
   return connect_job_factory_->CreateConnectJob(
-      using_ssl, HostPortPair::FromSchemeHostPort(group_id.destination()),
-      proxy_server, proxy_annotation_tag,
+      group_id.destination(), proxy_server, proxy_annotation_tag,
       socket_params->ssl_config_for_origin(),
       socket_params->ssl_config_for_proxy(), is_for_websockets_,
       group_id.privacy_mode(), resolution_callback, request_priority,
diff --git a/chromium/net/socket/client_socket_pool.h b/chromium/net/socket/client_socket_pool.h
index 900051df32b..131308d0d8a 100644
--- a/chromium/net/socket/client_socket_pool.h
+++ b/chromium/net/socket/client_socket_pool.h
@@ -28,9 +28,6 @@
 
 namespace base {
 class Value;
-namespace trace_event {
-class ProcessMemoryDump;
-}
 }  // namespace base
 
 namespace net {
@@ -171,6 +168,9 @@ class NET_EXPORT ClientSocketPool : public LowerLayeredPool {
     SocketParams(std::unique_ptr<SSLConfig> ssl_config_for_origin,
                  std::unique_ptr<SSLConfig> ssl_config_for_proxy);
 
+    SocketParams(const SocketParams&) = delete;
+    SocketParams& operator=(const SocketParams&) = delete;
+
     // Creates a  SocketParams object with none of the fields populated. This
     // works for the HTTP case only.
     static scoped_refptr<SocketParams> CreateForHttpForTesting();
@@ -189,10 +189,11 @@ class NET_EXPORT ClientSocketPool : public LowerLayeredPool {
 
     std::unique_ptr<SSLConfig> ssl_config_for_origin_;
     std::unique_ptr<SSLConfig> ssl_config_for_proxy_;
-
-    DISALLOW_COPY_AND_ASSIGN(SocketParams);
   };
 
+  ClientSocketPool(const ClientSocketPool&) = delete;
+  ClientSocketPool& operator=(const ClientSocketPool&) = delete;
+
   ~ClientSocketPool() override;
 
   // Requests a connected socket with a specified GroupId.
@@ -328,12 +329,6 @@ class NET_EXPORT ClientSocketPool : public LowerLayeredPool {
   virtual base::Value GetInfoAsValue(const std::string& name,
                                      const std::string& type) const = 0;
 
-  // Dumps memory allocation stats. |parent_dump_absolute_name| is the name
-  // used by the parent MemoryAllocatorDump in the memory dump hierarchy.
-  virtual void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const = 0;
-
   // Returns the maximum amount of time to wait before retrying a connect.
   static const int kMaxConnectRetryIntervalMs = 250;
 
@@ -364,8 +359,6 @@ class NET_EXPORT ClientSocketPool : public LowerLayeredPool {
   const bool is_for_websockets_;
   const CommonConnectJobParams* const common_connect_job_params_;
   const std::unique_ptr<ConnectJobFactory> connect_job_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSocketPool);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/client_socket_pool_base_unittest.cc b/chromium/net/socket/client_socket_pool_base_unittest.cc
index b9e924c6d0f..130b51caae4 100644
--- a/chromium/net/socket/client_socket_pool_base_unittest.cc
+++ b/chromium/net/socket/client_socket_pool_base_unittest.cc
@@ -33,6 +33,7 @@
 #include "net/base/network_isolation_key.h"
 #include "net/base/privacy_mode.h"
 #include "net/base/proxy_server.h"
+#include "net/base/proxy_string_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/schemeful_site.h"
 #include "net/base/test_completion_callback.h"
@@ -79,8 +80,7 @@ namespace {
 
 const int kDefaultMaxSockets = 4;
 const int kDefaultMaxSocketsPerGroup = 2;
-constexpr base::TimeDelta kUnusedIdleSocketTimeout =
-    base::TimeDelta::FromSeconds(10);
+constexpr base::TimeDelta kUnusedIdleSocketTimeout = base::Seconds(10);
 
 ClientSocketPool::GroupId TestGroupId(
     base::StringPiece host,
@@ -152,6 +152,9 @@ class MockClientSocket : public StreamSocket {
         net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)),
         was_used_to_convey_data_(false) {}
 
+  MockClientSocket(const MockClientSocket&) = delete;
+  MockClientSocket& operator=(const MockClientSocket&) = delete;
+
   // Sets whether the socket has unread data. If true, the next call to Read()
   // will return 1 byte and IsConnectedAndIdle() will return false.
   void set_has_unread_data(bool has_unread_data) {
@@ -223,8 +226,6 @@ class MockClientSocket : public StreamSocket {
   bool has_unread_data_;
   NetLogWithSource net_log_;
   bool was_used_to_convey_data_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class TestConnectJob;
@@ -343,6 +344,9 @@ class TestConnectJob : public ConnectJob {
         has_established_connection_(false),
         store_additional_error_state_(false) {}
 
+  TestConnectJob(const TestConnectJob&) = delete;
+  TestConnectJob& operator=(const TestConnectJob&) = delete;
+
   void Signal() {
     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
   }
@@ -407,7 +411,7 @@ class TestConnectJob : public ConnectJob {
             base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
                            weak_factory_.GetWeakPtr(), true /* successful */,
                            true /* async */, false /* cert_error */),
-            base::TimeDelta::FromMilliseconds(kPendingConnectDelay));
+            base::Milliseconds(kPendingConnectDelay));
         return ERR_IO_PENDING;
       case kMockPendingFailingJob:
         set_load_state(LOAD_STATE_CONNECTING);
@@ -416,7 +420,7 @@ class TestConnectJob : public ConnectJob {
             base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
                            weak_factory_.GetWeakPtr(), false /* error */,
                            true /* async */, false /* cert_error */),
-            base::TimeDelta::FromMilliseconds(2));
+            base::Milliseconds(2));
         return ERR_IO_PENDING;
       case kMockWaitingJob:
         set_load_state(LOAD_STATE_CONNECTING);
@@ -433,7 +437,7 @@ class TestConnectJob : public ConnectJob {
             base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
                            weak_factory_.GetWeakPtr(), false /* error */,
                            true /* async */, true /* cert_error */),
-            base::TimeDelta::FromMilliseconds(2));
+            base::Milliseconds(2));
         return ERR_IO_PENDING;
       case kMockAdditionalErrorStateJob:
         store_additional_error_state_ = true;
@@ -447,7 +451,7 @@ class TestConnectJob : public ConnectJob {
             base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
                            weak_factory_.GetWeakPtr(), false /* error */,
                            true /* async */, false /* cert_error */),
-            base::TimeDelta::FromMilliseconds(2));
+            base::Milliseconds(2));
         return ERR_IO_PENDING;
       case kMockUnreadDataJob: {
         int ret = DoConnect(true /* successful */, false /* sync */,
@@ -537,8 +541,6 @@ class TestConnectJob : public ConnectJob {
   bool store_additional_error_state_;
 
   base::WeakPtrFactory<TestConnectJob> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
 };
 
 class TestConnectJobFactory : public ConnectJobFactory {
@@ -546,6 +548,9 @@ class TestConnectJobFactory : public ConnectJobFactory {
   explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory)
       : client_socket_factory_(client_socket_factory) {}
 
+  TestConnectJobFactory(const TestConnectJobFactory&) = delete;
+  TestConnectJobFactory& operator=(const TestConnectJobFactory&) = delete;
+
   ~TestConnectJobFactory() override = default;
 
   void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
@@ -592,8 +597,6 @@ class TestConnectJobFactory : public ConnectJobFactory {
   std::list<TestConnectJob::JobType>* job_types_ = nullptr;
   base::TimeDelta timeout_duration_;
   MockClientSocketFactory* const client_socket_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory);
 };
 
 }  // namespace
@@ -1218,7 +1221,7 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
   // actually become pending until 2ms after they have been created. In order
   // to flush all tasks, we need to wait so that we know there are no
   // soon-to-be-pending tasks waiting.
-  FastForwardBy(base::TimeDelta::FromMilliseconds(10));
+  FastForwardBy(base::Milliseconds(10));
 
   // The next synchronous request should wait for its turn.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
@@ -1284,7 +1287,6 @@ TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
 
   ClientSocketHandle handles[4];
   for (size_t i = 0; i < base::size(handles); ++i) {
-    TestCompletionCallback callback;
     EXPECT_EQ(ERR_IO_PENDING,
               handles[i].Init(
                   TestGroupId("b"), params_, absl::nullopt, DEFAULT_PRIORITY,
@@ -1413,7 +1415,6 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
     EXPECT_FALSE(pool_->IsStalled());
     ClientSocketHandle handles[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
-      TestCompletionCallback callback;
       EXPECT_EQ(
           OK, handles[i].Init(
                   TestGroupId(base::StringPrintf("take-2-%d", i)), params_,
@@ -2588,7 +2589,7 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsReuse) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
-      base::TimeDelta::FromDays(1));  // Don't time out used sockets.
+      base::Days(1));     // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
@@ -2686,7 +2687,7 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsNoReuse) {
   // actually become pending until 2ms after they have been created. In order
   // to flush all tasks, we need to wait so that we know there are no
   // soon-to-be-pending tasks waiting.
-  FastForwardBy(base::TimeDelta::FromMilliseconds(10));
+  FastForwardBy(base::Milliseconds(10));
 
   // Both sockets should now be idle.
   ASSERT_EQ(2, pool_->IdleSocketCount());
@@ -2721,7 +2722,7 @@ TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
-      base::TimeDelta::FromDays(1));  // Don't time out used sockets.
+      base::Days(1));     // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
@@ -2779,7 +2780,7 @@ TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
   CreatePoolWithIdleTimeouts(
       4 /* socket limit */, 4 /* socket limit per group */,
       base::TimeDelta(),  // Time out unused sockets immediately.
-      base::TimeDelta::FromDays(1));  // Don't time out used sockets.
+      base::Days(1));     // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
@@ -3024,6 +3025,9 @@ class ConnectWithinCallback : public TestCompletionCallbackBase {
       TransportClientSocketPool* pool)
       : group_id_(group_id), params_(params), pool_(pool) {}
 
+  ConnectWithinCallback(const ConnectWithinCallback&) = delete;
+  ConnectWithinCallback& operator=(const ConnectWithinCallback&) = delete;
+
   ~ConnectWithinCallback() override = default;
 
   int WaitForNestedResult() {
@@ -3052,8 +3056,6 @@ class ConnectWithinCallback : public TestCompletionCallbackBase {
   TransportClientSocketPool* const pool_;
   ClientSocketHandle handle_;
   TestCompletionCallback nested_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
 };
 
 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
@@ -3095,15 +3097,15 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketWaitsForHostResolution) {
   // The backup timer fires but doesn't start a new ConnectJob while resolving
   // the hostname.
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 
   // Once the ConnectJob has finished resolving the hostname, the backup timer
   // will create a ConnectJob when it fires.
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING);
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
@@ -3125,14 +3127,14 @@ TEST_F(ClientSocketPoolBaseTest, NoBackupSocketWhenConnected) {
   // The backup timer fires but doesn't start a new ConnectJob while resolving
   // the hostname.
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
   client_socket_factory_.SetJobHasEstablishedConnection(0);
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
@@ -3159,7 +3161,6 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   ClientSocketHandle handles[kDefaultMaxSockets];
   for (int i = 1; i < kDefaultMaxSockets; ++i) {
-    TestCompletionCallback callback;
     EXPECT_EQ(OK, handles[i].Init(TestGroupId("bar"), params_, absl::nullopt,
                                   DEFAULT_PRIORITY, SocketTag(),
                                   ClientSocketPool::RespectLimits::ENABLED,
@@ -3174,8 +3175,8 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
   handle.Reset();
 
   // Wait for the backup timer to fire (add some slop to ensure it fires)
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
 }
@@ -3206,8 +3207,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
   // the backup time to see if it indeed got canceled.
   handle.Reset();
   // Wait for the backup timer to fire (add some slop to ensure it fires)
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("bar")));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("bar")));
 }
@@ -3244,8 +3245,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
   handle.Reset();
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
   // Wait for the backup timer to fire (add some slop to ensure it fires)
-  FastForwardBy(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
+  FastForwardBy(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
 }
 
 // Test delayed socket binding for the case where we have two connects,
@@ -4220,8 +4221,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
 
   // Make the ConnectJob hang until it times out, shorten the timeout.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
-  connect_job_factory_->set_timeout_duration(
-      base::TimeDelta::FromMilliseconds(500));
+  connect_job_factory_->set_timeout_duration(base::Milliseconds(500));
   pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
                         NetLogWithSource());
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -4237,7 +4237,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
   base::RunLoop loop;
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, loop.QuitClosure(), base::TimeDelta::FromSeconds(1));
+      FROM_HERE, loop.QuitClosure(), base::Seconds(1));
   loop.Run();
   EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
 }
@@ -5156,6 +5156,10 @@ TEST_F(ClientSocketPoolBaseTest, ProxyAuthNoAuthCallback) {
 class TestAuthHelper {
  public:
   TestAuthHelper() = default;
+
+  TestAuthHelper(const TestAuthHelper&) = delete;
+  TestAuthHelper& operator=(const TestAuthHelper&) = delete;
+
   ~TestAuthHelper() = default;
 
   void InitHandle(
@@ -5245,8 +5249,6 @@ class TestAuthHelper {
   ClientSocketHandle handle_;
   int auth_count_ = 0;
   TestCompletionCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestAuthHelper);
 };
 
 TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnce) {
@@ -5653,7 +5655,7 @@ class ClientSocketPoolBaseRefreshTest
             max_sockets, max_sockets_per_group, kUnusedIdleSocketTimeout,
             ClientSocketPool::used_idle_socket_timeout(),
             enable_backup_connect_jobs,
-            ProxyServer::FromPacString("HTTPS myproxy:70"));
+            PacResultElementToProxyServer("HTTPS myproxy:70"));
         break;
     }
   }
@@ -5857,7 +5859,7 @@ TEST_F(ClientSocketPoolBaseTest, RefreshProxyRefreshesAllGroups) {
                              kUnusedIdleSocketTimeout,
                              ClientSocketPool::used_idle_socket_timeout(),
                              false /* no backup connect jobs */,
-                             ProxyServer::FromPacString("HTTPS myproxy:70"));
+                             PacResultElementToProxyServer("HTTPS myproxy:70"));
 
   const ClientSocketPool::GroupId kGroupId1 =
       TestGroupId("a", 443, url::kHttpsScheme);
diff --git a/chromium/net/socket/client_socket_pool_manager.cc b/chromium/net/socket/client_socket_pool_manager.cc
index c8cf594a9a8..f9156b798fb 100644
--- a/chromium/net/socket/client_socket_pool_manager.cc
+++ b/chromium/net/socket/client_socket_pool_manager.cc
@@ -215,11 +215,9 @@ void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
 // static
 base::TimeDelta ClientSocketPoolManager::unused_idle_socket_timeout(
     HttpNetworkSession::SocketPoolType pool_type) {
-  return base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
+  return base::Seconds(base::GetFieldTrialParamByFeatureAsInt(
       net::features::kNetUnusedIdleSocketTimeout,
-      "unused_idle_socket_timeout_seconds",
-      60
-      ));
+      "unused_idle_socket_timeout_seconds", 60));
 }
 
 int InitSocketHandleForHttpRequest(
diff --git a/chromium/net/socket/client_socket_pool_manager.h b/chromium/net/socket/client_socket_pool_manager.h
index 69ea1ccbae3..b68e5f412c9 100644
--- a/chromium/net/socket/client_socket_pool_manager.h
+++ b/chromium/net/socket/client_socket_pool_manager.h
@@ -21,9 +21,6 @@
 
 namespace base {
 class Value;
-namespace trace_event {
-class ProcessMemoryDump;
-}
 }
 
 namespace net {
@@ -80,12 +77,6 @@ class NET_EXPORT_PRIVATE ClientSocketPoolManager {
 
   // Creates a Value summary of the state of the socket pools.
   virtual std::unique_ptr<base::Value> SocketPoolInfoToValue() const = 0;
-
-  // Dumps memory allocation stats. |parent_dump_absolute_name| is the name
-  // used by the parent MemoryAllocatorDump in the memory dump hierarchy.
-  virtual void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const = 0;
 };
 
 // A helper method that uses the passed in proxy information to initialize a
diff --git a/chromium/net/socket/client_socket_pool_manager_impl.cc b/chromium/net/socket/client_socket_pool_manager_impl.cc
index 0d7a15110f6..ed80c339cc1 100644
--- a/chromium/net/socket/client_socket_pool_manager_impl.cc
+++ b/chromium/net/socket/client_socket_pool_manager_impl.cc
@@ -10,6 +10,7 @@
 #include "base/check_op.h"
 #include "base/values.h"
 #include "net/base/proxy_server.h"
+#include "net/base/proxy_string_util.h"
 #include "net/http/http_network_session.h"
 #include "net/socket/socks_connect_job.h"
 #include "net/socket/ssl_connect_job.h"
@@ -104,21 +105,11 @@ ClientSocketPoolManagerImpl::SocketPoolInfoToValue() const {
     } else {
       type = "http_proxy_socket_pool";
     }
-    list->Append(
-        socket_pool.second->GetInfoAsValue(socket_pool.first.ToURI(), type));
+    list->Append(socket_pool.second->GetInfoAsValue(
+        ProxyServerToProxyUri(socket_pool.first), type));
   }
 
   return std::move(list);
 }
 
-void ClientSocketPoolManagerImpl::DumpMemoryStats(
-    base::trace_event::ProcessMemoryDump* pmd,
-    const std::string& parent_dump_absolute_name) const {
-  SocketPoolMap::const_iterator socket_pool =
-      socket_pools_.find(ProxyServer::Direct());
-  if (socket_pool == socket_pools_.end())
-    return;
-  socket_pool->second->DumpMemoryStats(pmd, parent_dump_absolute_name);
-}
-
 }  // namespace net
diff --git a/chromium/net/socket/client_socket_pool_manager_impl.h b/chromium/net/socket/client_socket_pool_manager_impl.h
index dfeba2f158e..f70679aa785 100644
--- a/chromium/net/socket/client_socket_pool_manager_impl.h
+++ b/chromium/net/socket/client_socket_pool_manager_impl.h
@@ -19,12 +19,6 @@
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/connect_job.h"
 
-namespace base {
-namespace trace_event {
-class ProcessMemoryDump;
-}
-}
-
 namespace net {
 
 class ProxyServer;
@@ -40,6 +34,11 @@ class NET_EXPORT_PRIVATE ClientSocketPoolManagerImpl
       const CommonConnectJobParams& common_connect_job_params,
       const CommonConnectJobParams& websocket_common_connect_job_params,
       HttpNetworkSession::SocketPoolType pool_type);
+
+  ClientSocketPoolManagerImpl(const ClientSocketPoolManagerImpl&) = delete;
+  ClientSocketPoolManagerImpl& operator=(const ClientSocketPoolManagerImpl&) =
+      delete;
+
   ~ClientSocketPoolManagerImpl() override;
 
   void FlushSocketPoolsWithError(int net_error,
@@ -51,10 +50,6 @@ class NET_EXPORT_PRIVATE ClientSocketPoolManagerImpl
   // Creates a Value summary of the state of the socket pools.
   std::unique_ptr<base::Value> SocketPoolInfoToValue() const override;
 
-  void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const override;
-
  private:
   using SocketPoolMap =
       std::map<ProxyServer, std::unique_ptr<ClientSocketPool>>;
@@ -68,8 +63,6 @@ class NET_EXPORT_PRIVATE ClientSocketPoolManagerImpl
   SocketPoolMap socket_pools_;
 
   THREAD_CHECKER(thread_checker_);
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolManagerImpl);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/connect_job.h b/chromium/net/socket/connect_job.h
index a662e0e156a..a5df43c9299 100644
--- a/chromium/net/socket/connect_job.h
+++ b/chromium/net/socket/connect_job.h
@@ -126,6 +126,10 @@ class NET_EXPORT_PRIVATE ConnectJob {
   class NET_EXPORT_PRIVATE Delegate {
    public:
     Delegate() {}
+
+    Delegate(const Delegate&) = delete;
+    Delegate& operator=(const Delegate&) = delete;
+
     virtual ~Delegate() {}
 
     // Alerts the delegate that the connection completed. |job| must be
@@ -147,9 +151,6 @@ class NET_EXPORT_PRIVATE ConnectJob {
                                   HttpAuthController* auth_controller,
                                   base::OnceClosure restart_with_auth_callback,
                                   ConnectJob* job) = 0;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
@@ -167,6 +168,10 @@ class NET_EXPORT_PRIVATE ConnectJob {
              const NetLogWithSource* net_log,
              NetLogSourceType net_log_source_type,
              NetLogEventType net_log_connect_event_type);
+
+  ConnectJob(const ConnectJob&) = delete;
+  ConnectJob& operator=(const ConnectJob&) = delete;
+
   virtual ~ConnectJob();
 
   // Accessors
@@ -308,8 +313,6 @@ class NET_EXPORT_PRIVATE ConnectJob {
   const bool top_level_job_;
   NetLogWithSource net_log_;
   const NetLogEventType net_log_connect_event_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/connect_job_test_util.h b/chromium/net/socket/connect_job_test_util.h
index d6cc9f9d4d5..68a4da6e669 100644
--- a/chromium/net/socket/connect_job_test_util.h
+++ b/chromium/net/socket/connect_job_test_util.h
@@ -31,6 +31,10 @@ class TestConnectJobDelegate : public ConnectJob::Delegate {
 
   explicit TestConnectJobDelegate(
       SocketExpected socket_expected = SocketExpected::ON_SUCCESS_ONLY);
+
+  TestConnectJobDelegate(const TestConnectJobDelegate&) = delete;
+  TestConnectJobDelegate& operator=(const TestConnectJobDelegate&) = delete;
+
   ~TestConnectJobDelegate() override;
 
   // ConnectJob::Delegate implementation.
@@ -84,8 +88,6 @@ class TestConnectJobDelegate : public ConnectJob::Delegate {
 
   base::RunLoop run_loop_;
   std::unique_ptr<base::RunLoop> auth_challenge_run_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestConnectJobDelegate);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/connect_job_unittest.cc b/chromium/net/socket/connect_job_unittest.cc
index 230396e638e..459c143b752 100644
--- a/chromium/net/socket/connect_job_unittest.cc
+++ b/chromium/net/socket/connect_job_unittest.cc
@@ -60,6 +60,9 @@ class TestConnectJob : public ConnectJob {
     }
   }
 
+  TestConnectJob(const TestConnectJob&) = delete;
+  TestConnectJob& operator=(const TestConnectJob&) = delete;
+
   // From ConnectJob:
   LoadState GetLoadState() const override { return LOAD_STATE_IDLE; }
   bool HasEstablishedConnection() const override { return false; }
@@ -86,8 +89,6 @@ class TestConnectJob : public ConnectJob {
   const JobType job_type_;
   StaticSocketDataProvider socket_data_provider_;
   RequestPriority last_seen_priority_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
 };
 
 class ConnectJobTest : public testing::Test {
@@ -122,16 +123,15 @@ class ConnectJobTest : public testing::Test {
 // completion.
 TEST_F(ConnectJobTest, NoTimeoutOnSyncCompletion) {
   TestConnectJob job(TestConnectJob::JobType::kSyncSuccess,
-                     base::TimeDelta::FromMicroseconds(1),
-                     &common_connect_job_params_, &delegate_);
+                     base::Microseconds(1), &common_connect_job_params_,
+                     &delegate_);
   EXPECT_THAT(job.Connect(), test::IsOk());
 }
 
 // Even though a timeout is specified, it doesn't time out on an asynchronous
 // completion.
 TEST_F(ConnectJobTest, NoTimeoutOnAsyncCompletion) {
-  TestConnectJob job(TestConnectJob::JobType::kAsyncSuccess,
-                     base::TimeDelta::FromMinutes(1),
+  TestConnectJob job(TestConnectJob::JobType::kAsyncSuccess, base::Minutes(1),
                      &common_connect_job_params_, &delegate_);
   ASSERT_THAT(job.Connect(), test::IsError(ERR_IO_PENDING));
   EXPECT_THAT(delegate_.WaitForResult(), test::IsOk());
@@ -150,8 +150,8 @@ TEST_F(ConnectJobTest, NoTimeoutWithNoTimeDelta) {
 // subclasses during the SetPriorityInternal call.
 TEST_F(ConnectJobTest, SetPriority) {
   TestConnectJob job(TestConnectJob::JobType::kAsyncSuccess,
-                     base::TimeDelta::FromMicroseconds(1),
-                     &common_connect_job_params_, &delegate_);
+                     base::Microseconds(1), &common_connect_job_params_,
+                     &delegate_);
   ASSERT_THAT(job.Connect(), test::IsError(ERR_IO_PENDING));
 
   job.ChangePriority(HIGHEST);
@@ -166,7 +166,7 @@ TEST_F(ConnectJobTest, SetPriority) {
 }
 
 TEST_F(ConnectJobTest, TimedOut) {
-  const base::TimeDelta kTimeout = base::TimeDelta::FromHours(1);
+  const base::TimeDelta kTimeout = base::Hours(1);
 
   std::unique_ptr<TestConnectJob> job =
       std::make_unique<TestConnectJob>(TestConnectJob::JobType::kHung, kTimeout,
@@ -174,13 +174,12 @@ TEST_F(ConnectJobTest, TimedOut) {
   ASSERT_THAT(job->Connect(), test::IsError(ERR_IO_PENDING));
 
   // Nothing should happen before the specified time.
-  task_environment_.FastForwardBy(kTimeout -
-                                  base::TimeDelta::FromMilliseconds(1));
+  task_environment_.FastForwardBy(kTimeout - base::Milliseconds(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(delegate_.has_result());
 
   // At which point the job should time out.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(1));
+  task_environment_.FastForwardBy(base::Milliseconds(1));
   EXPECT_THAT(delegate_.WaitForResult(), test::IsError(ERR_TIMED_OUT));
 
   // Have to delete the job for it to log the end event.
@@ -204,26 +203,24 @@ TEST_F(ConnectJobTest, TimedOut) {
 }
 
 TEST_F(ConnectJobTest, TimedOutWithRestartedTimer) {
-  const base::TimeDelta kTimeout = base::TimeDelta::FromHours(1);
+  const base::TimeDelta kTimeout = base::Hours(1);
 
   TestConnectJob job(TestConnectJob::JobType::kHung, kTimeout,
                      &common_connect_job_params_, &delegate_);
   ASSERT_THAT(job.Connect(), test::IsError(ERR_IO_PENDING));
 
   // Nothing should happen before the specified time.
-  task_environment_.FastForwardBy(kTimeout -
-                                  base::TimeDelta::FromMilliseconds(1));
+  task_environment_.FastForwardBy(kTimeout - base::Milliseconds(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(delegate_.has_result());
 
   // Make sure restarting the timer is respected.
   job.ResetTimer(kTimeout);
-  task_environment_.FastForwardBy(kTimeout -
-                                  base::TimeDelta::FromMilliseconds(1));
+  task_environment_.FastForwardBy(kTimeout - base::Milliseconds(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(delegate_.has_result());
 
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(1));
+  task_environment_.FastForwardBy(base::Milliseconds(1));
   EXPECT_THAT(delegate_.WaitForResult(), test::IsError(ERR_TIMED_OUT));
 }
 
diff --git a/chromium/net/socket/fuzzed_datagram_client_socket.h b/chromium/net/socket/fuzzed_datagram_client_socket.h
index f53eaecf430..d13b2e49e70 100644
--- a/chromium/net/socket/fuzzed_datagram_client_socket.h
+++ b/chromium/net/socket/fuzzed_datagram_client_socket.h
@@ -29,6 +29,11 @@ class FuzzedDatagramClientSocket : public DatagramClientSocket {
  public:
   // |data_provider| must outlive the created socket.
   explicit FuzzedDatagramClientSocket(FuzzedDataProvider* data_provider);
+
+  FuzzedDatagramClientSocket(const FuzzedDatagramClientSocket&) = delete;
+  FuzzedDatagramClientSocket& operator=(const FuzzedDatagramClientSocket&) =
+      delete;
+
   ~FuzzedDatagramClientSocket() override;
 
   // DatagramClientSocket implementation:
@@ -92,8 +97,6 @@ class FuzzedDatagramClientSocket : public DatagramClientSocket {
   IPEndPoint remote_address_;
 
   base::WeakPtrFactory<FuzzedDatagramClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(FuzzedDatagramClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/fuzzed_server_socket.h b/chromium/net/socket/fuzzed_server_socket.h
index 7d8dc80b566..cdcc3398965 100644
--- a/chromium/net/socket/fuzzed_server_socket.h
+++ b/chromium/net/socket/fuzzed_server_socket.h
@@ -32,6 +32,10 @@ class FuzzedServerSocket : public ServerSocket {
   // must remain valid until after both this object and the StreamSocket
   // produced by Accept are destroyed.
   FuzzedServerSocket(FuzzedDataProvider* data_provider, net::NetLog* net_log);
+
+  FuzzedServerSocket(const FuzzedServerSocket&) = delete;
+  FuzzedServerSocket& operator=(const FuzzedServerSocket&) = delete;
+
   ~FuzzedServerSocket() override;
 
   int Listen(const IPEndPoint& address, int backlog) override;
@@ -52,7 +56,6 @@ class FuzzedServerSocket : public ServerSocket {
   bool listen_called_;
 
   base::WeakPtrFactory<FuzzedServerSocket> weak_factory_{this};
-  DISALLOW_COPY_AND_ASSIGN(FuzzedServerSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/fuzzed_socket.h b/chromium/net/socket/fuzzed_socket.h
index 8e420c10dac..3cfc6238530 100644
--- a/chromium/net/socket/fuzzed_socket.h
+++ b/chromium/net/socket/fuzzed_socket.h
@@ -42,6 +42,10 @@ class FuzzedSocket : public TransportClientSocket {
   // |data_provider| is used as to determine behavior of the FuzzedSocket. It
   // must remain valid until after the FuzzedSocket is destroyed.
   FuzzedSocket(FuzzedDataProvider* data_provider, net::NetLog* net_log);
+
+  FuzzedSocket(const FuzzedSocket&) = delete;
+  FuzzedSocket& operator=(const FuzzedSocket&) = delete;
+
   ~FuzzedSocket() override;
 
   // If set to true, the socket will fuzz the result of the Connect() call.
@@ -132,8 +136,6 @@ class FuzzedSocket : public TransportClientSocket {
   IPEndPoint remote_address_;
 
   base::WeakPtrFactory<FuzzedSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(FuzzedSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/fuzzed_socket_factory.cc b/chromium/net/socket/fuzzed_socket_factory.cc
index fc7da36567b..2c77be921fe 100644
--- a/chromium/net/socket/fuzzed_socket_factory.cc
+++ b/chromium/net/socket/fuzzed_socket_factory.cc
@@ -28,6 +28,10 @@ namespace {
 class FailingSSLClientSocket : public SSLClientSocket {
  public:
   FailingSSLClientSocket() = default;
+
+  FailingSSLClientSocket(const FailingSSLClientSocket&) = delete;
+  FailingSSLClientSocket& operator=(const FailingSSLClientSocket&) = delete;
+
   ~FailingSSLClientSocket() override = default;
 
   // Socket implementation:
@@ -100,8 +104,6 @@ class FailingSSLClientSocket : public SSLClientSocket {
 
  private:
   NetLogWithSource net_log_;
-
-  DISALLOW_COPY_AND_ASSIGN(FailingSSLClientSocket);
 };
 
 }  // namespace
diff --git a/chromium/net/socket/fuzzed_socket_factory.h b/chromium/net/socket/fuzzed_socket_factory.h
index 5d1940ae693..3ecd386c29d 100644
--- a/chromium/net/socket/fuzzed_socket_factory.h
+++ b/chromium/net/socket/fuzzed_socket_factory.h
@@ -32,6 +32,10 @@ class FuzzedSocketFactory : public ClientSocketFactory {
   // long as their calls into it are made on the CLientSocketFactory's thread
   // and the calls are deterministic.
   explicit FuzzedSocketFactory(FuzzedDataProvider* data_provider);
+
+  FuzzedSocketFactory(const FuzzedSocketFactory&) = delete;
+  FuzzedSocketFactory& operator=(const FuzzedSocketFactory&) = delete;
+
   ~FuzzedSocketFactory() override;
 
   std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
@@ -71,8 +75,6 @@ class FuzzedSocketFactory : public ClientSocketFactory {
  private:
   FuzzedDataProvider* data_provider_;
   bool fuzz_connect_result_;
-
-  DISALLOW_COPY_AND_ASSIGN(FuzzedSocketFactory);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/mock_client_socket_pool_manager.cc b/chromium/net/socket/mock_client_socket_pool_manager.cc
index 41bea61f741..49b50b2c731 100644
--- a/chromium/net/socket/mock_client_socket_pool_manager.cc
+++ b/chromium/net/socket/mock_client_socket_pool_manager.cc
@@ -45,8 +45,4 @@ MockClientSocketPoolManager::SocketPoolInfoToValue() const {
   return std::unique_ptr<base::Value>(nullptr);
 }
 
-void MockClientSocketPoolManager::DumpMemoryStats(
-    base::trace_event::ProcessMemoryDump* pmd,
-    const std::string& parent_dump_absolute_name) const {}
-
 }  // namespace net
diff --git a/chromium/net/socket/mock_client_socket_pool_manager.h b/chromium/net/socket/mock_client_socket_pool_manager.h
index 782aea43bbc..ea1891cadf7 100644
--- a/chromium/net/socket/mock_client_socket_pool_manager.h
+++ b/chromium/net/socket/mock_client_socket_pool_manager.h
@@ -21,6 +21,11 @@ class ClientSocketPool;
 class MockClientSocketPoolManager : public ClientSocketPoolManager {
  public:
   MockClientSocketPoolManager();
+
+  MockClientSocketPoolManager(const MockClientSocketPoolManager&) = delete;
+  MockClientSocketPoolManager& operator=(const MockClientSocketPoolManager&) =
+      delete;
+
   ~MockClientSocketPoolManager() override;
 
   // Sets socket pool that gets used for the specified ProxyServer.
@@ -33,17 +38,12 @@ class MockClientSocketPoolManager : public ClientSocketPoolManager {
   void CloseIdleSockets(const char* net_log_reason_utf8) override;
   ClientSocketPool* GetSocketPool(const ProxyServer& proxy_server) override;
   std::unique_ptr<base::Value> SocketPoolInfoToValue() const override;
-  void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const override;
 
  private:
   using ClientSocketPoolMap =
       std::map<ProxyServer, std::unique_ptr<ClientSocketPool>>;
 
   ClientSocketPoolMap socket_pools_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockClientSocketPoolManager);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/sequenced_socket_data_unittest.cc b/chromium/net/socket/sequenced_socket_data_unittest.cc
index b65552165b3..c4cbb3af786 100644
--- a/chromium/net/socket/sequenced_socket_data_unittest.cc
+++ b/chromium/net/socket/sequenced_socket_data_unittest.cc
@@ -57,6 +57,9 @@ class ReentrantHelper {
         second_write_data_(nullptr),
         second_len_(-1) {}
 
+  ReentrantHelper(const ReentrantHelper&) = delete;
+  ReentrantHelper& operator=(const ReentrantHelper&) = delete;
+
   // Expect that the previous operation will return |first_len| and will fill
   // |first_read_data_| with |first_read_data|.
   void SetExpectedRead(const char* first_read_data, int first_len) {
@@ -144,8 +147,6 @@ class ReentrantHelper {
   scoped_refptr<IOBuffer> second_read_buf_;
   const char* second_write_data_;
   int second_len_;
-
-  DISALLOW_COPY_AND_ASSIGN(ReentrantHelper);
 };
 
 class SequencedSocketDataTest : public TestWithTaskEnvironment {
diff --git a/chromium/net/socket/server_socket.h b/chromium/net/socket/server_socket.h
index 210e47f0781..9575c7486fe 100644
--- a/chromium/net/socket/server_socket.h
+++ b/chromium/net/socket/server_socket.h
@@ -22,6 +22,10 @@ class StreamSocket;
 class NET_EXPORT ServerSocket {
  public:
   ServerSocket();
+
+  ServerSocket(const ServerSocket&) = delete;
+  ServerSocket& operator=(const ServerSocket&) = delete;
+
   virtual ~ServerSocket();
 
   // Binds the socket and starts listening. Destroys the socket to stop
@@ -48,9 +52,6 @@ class NET_EXPORT ServerSocket {
   virtual int Accept(std::unique_ptr<StreamSocket>* socket,
                      CompletionOnceCallback callback,
                      IPEndPoint* peer_address);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ServerSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socket_bio_adapter.h b/chromium/net/socket/socket_bio_adapter.h
index 98421c701e4..600da8c9ee6 100644
--- a/chromium/net/socket/socket_bio_adapter.h
+++ b/chromium/net/socket/socket_bio_adapter.h
@@ -70,6 +70,10 @@ class NET_EXPORT_PRIVATE SocketBIOAdapter {
                    int read_buffer_capacity,
                    int write_buffer_capacity,
                    Delegate* delegate);
+
+  SocketBIOAdapter(const SocketBIOAdapter&) = delete;
+  SocketBIOAdapter& operator=(const SocketBIOAdapter&) = delete;
+
   ~SocketBIOAdapter();
 
   BIO* bio() { return bio_.get(); }
@@ -137,8 +141,6 @@ class NET_EXPORT_PRIVATE SocketBIOAdapter {
   Delegate* delegate_;
 
   base::WeakPtrFactory<SocketBIOAdapter> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(SocketBIOAdapter);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socket_performance_watcher_factory.h b/chromium/net/socket/socket_performance_watcher_factory.h
index bb78a56665f..4925332d08f 100644
--- a/chromium/net/socket/socket_performance_watcher_factory.h
+++ b/chromium/net/socket/socket_performance_watcher_factory.h
@@ -23,6 +23,11 @@ class NET_EXPORT_PRIVATE SocketPerformanceWatcherFactory {
   // |SocketPerformanceWatcherFactory|.
   enum Protocol { PROTOCOL_TCP, PROTOCOL_QUIC };
 
+  SocketPerformanceWatcherFactory(const SocketPerformanceWatcherFactory&) =
+      delete;
+  SocketPerformanceWatcherFactory& operator=(
+      const SocketPerformanceWatcherFactory&) = delete;
+
   virtual ~SocketPerformanceWatcherFactory() {}
 
   // Creates a socket performance watcher that will record statistics for a
@@ -37,9 +42,6 @@ class NET_EXPORT_PRIVATE SocketPerformanceWatcherFactory {
 
  protected:
   SocketPerformanceWatcherFactory() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SocketPerformanceWatcherFactory);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socket_posix.h b/chromium/net/socket/socket_posix.h
index dc3f2106a80..23259b37132 100644
--- a/chromium/net/socket/socket_posix.h
+++ b/chromium/net/socket/socket_posix.h
@@ -28,6 +28,10 @@ class NET_EXPORT_PRIVATE SocketPosix
     : public base::MessagePumpForIO::FdWatcher {
  public:
   SocketPosix();
+
+  SocketPosix(const SocketPosix&) = delete;
+  SocketPosix& operator=(const SocketPosix&) = delete;
+
   ~SocketPosix() override;
 
   // Opens a socket and returns net::OK if |address_family| is AF_INET, AF_INET6
@@ -152,8 +156,6 @@ class NET_EXPORT_PRIVATE SocketPosix
   std::unique_ptr<SockaddrStorage> peer_address_;
 
   base::ThreadChecker thread_checker_;
-
-  DISALLOW_COPY_AND_ASSIGN(SocketPosix);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socket_test_util.cc b/chromium/net/socket/socket_test_util.cc
index 9f3195dbc65..b072d40e454 100644
--- a/chromium/net/socket/socket_test_util.cc
+++ b/chromium/net/socket/socket_test_util.cc
@@ -370,8 +370,8 @@ SequencedSocketData::SequencedSocketData(base::span<const MockRead> reads,
                                          base::span<const MockWrite> writes)
     : helper_(reads, writes),
       sequence_number_(0),
-      read_state_(IDLE),
-      write_state_(IDLE),
+      read_state_(IoState::kIdle),
+      write_state_(IoState::kIdle),
       busy_before_sync_reads_(false) {
   // Check that reads and writes have a contiguous set of sequence numbers
   // starting from 0 and working their way up, with no repeats and skipping
@@ -451,7 +451,7 @@ SequencedSocketData::SequencedSocketData(const MockConnect& connect,
 }
 
 MockRead SequencedSocketData::OnRead() {
-  CHECK_EQ(IDLE, read_state_);
+  CHECK_EQ(IoState::kIdle, read_state_);
   CHECK(!helper_.AllReadDataConsumed())
       << "Application tried to read but there is no read data left";
 
@@ -473,7 +473,7 @@ MockRead SequencedSocketData::OnRead() {
     // If the result is ERR_IO_PENDING, then pause.
     if (next_read.result == ERR_IO_PENDING) {
       NET_TRACE(1, " *** ") << "Pausing read at: " << sequence_number_;
-      read_state_ = PAUSED;
+      read_state_ = IoState::kPaused;
       if (run_until_paused_run_loop_)
         run_until_paused_run_loop_->Quit();
       return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -481,21 +481,21 @@ MockRead SequencedSocketData::OnRead() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::BindOnce(&SequencedSocketData::OnReadComplete,
                                   weak_factory_.GetWeakPtr()));
-    CHECK_NE(COMPLETING, write_state_);
-    read_state_ = COMPLETING;
+    CHECK_NE(IoState::kCompleting, write_state_);
+    read_state_ = IoState::kCompleting;
   } else if (next_read.mode == SYNCHRONOUS) {
     ADD_FAILURE() << "Unable to perform synchronous IO while stopped";
     return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   } else {
     NET_TRACE(1, " *** ") << "Waiting for write to trigger read";
-    read_state_ = PENDING;
+    read_state_ = IoState::kPending;
   }
 
   return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
 }
 
 MockWriteResult SequencedSocketData::OnWrite(const std::string& data) {
-  CHECK_EQ(IDLE, write_state_);
+  CHECK_EQ(IoState::kIdle, write_state_);
   CHECK(!helper_.AllWriteDataConsumed())
       << "\nNo more mock data to match write:\nFormatted write data:\n"
       << printer_->PrintWrite(data) << "Raw write data:\n"
@@ -525,7 +525,7 @@ MockWriteResult SequencedSocketData::OnWrite(const std::string& data) {
     // If the result is ERR_IO_PENDING, then pause.
     if (next_write.result == ERR_IO_PENDING) {
       NET_TRACE(1, " *** ") << "Pausing write at: " << sequence_number_;
-      write_state_ = PAUSED;
+      write_state_ = IoState::kPaused;
       if (run_until_paused_run_loop_)
         run_until_paused_run_loop_->Quit();
       return MockWriteResult(SYNCHRONOUS, ERR_IO_PENDING);
@@ -535,14 +535,14 @@ MockWriteResult SequencedSocketData::OnWrite(const std::string& data) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::BindOnce(&SequencedSocketData::OnWriteComplete,
                                   weak_factory_.GetWeakPtr()));
-    CHECK_NE(COMPLETING, read_state_);
-    write_state_ = COMPLETING;
+    CHECK_NE(IoState::kCompleting, read_state_);
+    write_state_ = IoState::kCompleting;
   } else if (next_write.mode == SYNCHRONOUS) {
     ADD_FAILURE() << "Unable to perform synchronous IO while stopped";
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
   } else {
     NET_TRACE(1, " *** ") << "Waiting for read to trigger write";
-    write_state_ = PENDING;
+    write_state_ = IoState::kPending;
   }
 
   return MockWriteResult(SYNCHRONOUS, ERR_IO_PENDING);
@@ -553,9 +553,9 @@ bool SequencedSocketData::AllReadDataConsumed() const {
 }
 
 void SequencedSocketData::CancelPendingRead() {
-  DCHECK_EQ(PENDING, read_state_);
+  DCHECK_EQ(IoState::kPending, read_state_);
 
-  read_state_ = IDLE;
+  read_state_ = IoState::kIdle;
 }
 
 bool SequencedSocketData::AllWriteDataConsumed() const {
@@ -578,8 +578,8 @@ bool SequencedSocketData::IsIdle() const {
 
 bool SequencedSocketData::IsPaused() const {
   // Both states should not be paused.
-  DCHECK(read_state_ != PAUSED || write_state_ != PAUSED);
-  return write_state_ == PAUSED || read_state_ == PAUSED;
+  DCHECK(read_state_ != IoState::kPaused || write_state_ != IoState::kPaused);
+  return write_state_ == IoState::kPaused || read_state_ == IoState::kPaused;
 }
 
 void SequencedSocketData::Resume() {
@@ -589,11 +589,11 @@ void SequencedSocketData::Resume() {
   }
 
   sequence_number_++;
-  if (read_state_ == PAUSED) {
-    read_state_ = PENDING;
+  if (read_state_ == IoState::kPaused) {
+    read_state_ = IoState::kPending;
     helper_.AdvanceRead();
-  } else {  // write_state_ == PAUSED
-    write_state_ = PENDING;
+  } else {  // write_state_ == IoState::kPaused
+    write_state_ = IoState::kPending;
     helper_.AdvanceWrite();
   }
 
@@ -601,9 +601,9 @@ void SequencedSocketData::Resume() {
       helper_.PeekWrite().sequence_number == sequence_number_) {
     // The next event hasn't even started yet.  Pausing isn't really needed in
     // that case, but may as well support it.
-    if (write_state_ != PENDING)
+    if (write_state_ != IoState::kPending)
       return;
-    write_state_ = COMPLETING;
+    write_state_ = IoState::kCompleting;
     OnWriteComplete();
     return;
   }
@@ -612,9 +612,9 @@ void SequencedSocketData::Resume() {
 
   // The next event hasn't even started yet.  Pausing isn't really needed in
   // that case, but may as well support it.
-  if (read_state_ != PENDING)
+  if (read_state_ != IoState::kPending)
     return;
-  read_state_ = COMPLETING;
+  read_state_ = IoState::kCompleting;
   OnReadComplete();
 }
 
@@ -634,7 +634,7 @@ void SequencedSocketData::MaybePostReadCompleteTask() {
   NET_TRACE(1, " ****** ") << " current: " << sequence_number_;
   // Only trigger the next read to complete if there is already a read pending
   // which should complete at the current sequence number.
-  if (read_state_ != PENDING ||
+  if (read_state_ != IoState::kPending ||
       helper_.PeekRead().sequence_number != sequence_number_) {
     return;
   }
@@ -642,7 +642,7 @@ void SequencedSocketData::MaybePostReadCompleteTask() {
   // If the result is ERR_IO_PENDING, then pause.
   if (helper_.PeekRead().result == ERR_IO_PENDING) {
     NET_TRACE(1, " *** ") << "Pausing read at: " << sequence_number_;
-    read_state_ = PAUSED;
+    read_state_ = IoState::kPaused;
     if (run_until_paused_run_loop_)
       run_until_paused_run_loop_->Quit();
     return;
@@ -653,15 +653,15 @@ void SequencedSocketData::MaybePostReadCompleteTask() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&SequencedSocketData::OnReadComplete,
                                 weak_factory_.GetWeakPtr()));
-  CHECK_NE(COMPLETING, write_state_);
-  read_state_ = COMPLETING;
+  CHECK_NE(IoState::kCompleting, write_state_);
+  read_state_ = IoState::kCompleting;
 }
 
 void SequencedSocketData::MaybePostWriteCompleteTask() {
   NET_TRACE(1, " ****** ") << " current: " << sequence_number_;
   // Only trigger the next write to complete if there is already a write pending
   // which should complete at the current sequence number.
-  if (write_state_ != PENDING ||
+  if (write_state_ != IoState::kPending ||
       helper_.PeekWrite().sequence_number != sequence_number_) {
     return;
   }
@@ -669,7 +669,7 @@ void SequencedSocketData::MaybePostWriteCompleteTask() {
   // If the result is ERR_IO_PENDING, then pause.
   if (helper_.PeekWrite().result == ERR_IO_PENDING) {
     NET_TRACE(1, " *** ") << "Pausing write at: " << sequence_number_;
-    write_state_ = PAUSED;
+    write_state_ = IoState::kPaused;
     if (run_until_paused_run_loop_)
       run_until_paused_run_loop_->Quit();
     return;
@@ -680,26 +680,26 @@ void SequencedSocketData::MaybePostWriteCompleteTask() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&SequencedSocketData::OnWriteComplete,
                                 weak_factory_.GetWeakPtr()));
-  CHECK_NE(COMPLETING, read_state_);
-  write_state_ = COMPLETING;
+  CHECK_NE(IoState::kCompleting, read_state_);
+  write_state_ = IoState::kCompleting;
 }
 
 void SequencedSocketData::Reset() {
   helper_.Reset();
   sequence_number_ = 0;
-  read_state_ = IDLE;
-  write_state_ = IDLE;
+  read_state_ = IoState::kIdle;
+  write_state_ = IoState::kIdle;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void SequencedSocketData::OnReadComplete() {
-  CHECK_EQ(COMPLETING, read_state_);
+  CHECK_EQ(IoState::kCompleting, read_state_);
   NET_TRACE(1, " *** ") << "Completing read for: " << sequence_number_;
 
   MockRead data = helper_.AdvanceRead();
   DCHECK_EQ(sequence_number_, data.sequence_number);
   sequence_number_++;
-  read_state_ = IDLE;
+  read_state_ = IoState::kIdle;
 
   // The result of this read completing might trigger the completion
   // of a pending write. If so, post a task to complete the write later.
@@ -721,13 +721,13 @@ void SequencedSocketData::OnReadComplete() {
 }
 
 void SequencedSocketData::OnWriteComplete() {
-  CHECK_EQ(COMPLETING, write_state_);
+  CHECK_EQ(IoState::kCompleting, write_state_);
   NET_TRACE(1, " *** ") << " Completing write for: " << sequence_number_;
 
   const MockWrite& data = helper_.AdvanceWrite();
   DCHECK_EQ(sequence_number_, data.sequence_number);
   sequence_number_++;
-  write_state_ = IDLE;
+  write_state_ = IoState::kIdle;
   int rv = data.result == OK ? data.data_len : data.result;
 
   // The result of this write completing might trigger the completion
@@ -2176,7 +2176,7 @@ MockTransportClientSocketPool::MockTransportClientSocketPool(
     : TransportClientSocketPool(
           max_sockets,
           max_sockets_per_group,
-          base::TimeDelta::FromSeconds(10) /* unused_idle_socket_timeout */,
+          base::Seconds(10) /* unused_idle_socket_timeout */,
           ProxyServer::Direct(),
           false /* is_for_websockets */,
           common_connect_job_params),
diff --git a/chromium/net/socket/socket_test_util.h b/chromium/net/socket/socket_test_util.h
index 4df01324ac4..fb217896888 100644
--- a/chromium/net/socket/socket_test_util.h
+++ b/chromium/net/socket/socket_test_util.h
@@ -223,6 +223,10 @@ struct MockWriteResult {
 class SocketDataProvider {
  public:
   SocketDataProvider();
+
+  SocketDataProvider(const SocketDataProvider&) = delete;
+  SocketDataProvider& operator=(const SocketDataProvider&) = delete;
+
   virtual ~SocketDataProvider();
 
   // Returns the buffer and result code for the next simulated read.
@@ -326,8 +330,6 @@ class SocketDataProvider {
   int set_send_buffer_size_result_ = net::OK;
   bool set_no_delay_result_ = true;
   bool set_keep_alive_result_ = true;
-
-  DISALLOW_COPY_AND_ASSIGN(SocketDataProvider);
 };
 
 // The AsyncSocket is an interface used by the SocketDataProvider to
@@ -368,6 +370,10 @@ class StaticSocketDataHelper {
  public:
   StaticSocketDataHelper(base::span<const MockRead> reads,
                          base::span<const MockWrite> writes);
+
+  StaticSocketDataHelper(const StaticSocketDataHelper&) = delete;
+  StaticSocketDataHelper& operator=(const StaticSocketDataHelper&) = delete;
+
   ~StaticSocketDataHelper();
 
   // These functions get access to the next available read and write data. They
@@ -404,8 +410,6 @@ class StaticSocketDataHelper {
   size_t read_index_;
   const base::span<const MockWrite> writes_;
   size_t write_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(StaticSocketDataHelper);
 };
 
 // SocketDataProvider which responds based on static tables of mock reads and
@@ -415,6 +419,10 @@ class StaticSocketDataProvider : public SocketDataProvider {
   StaticSocketDataProvider();
   StaticSocketDataProvider(base::span<const MockRead> reads,
                            base::span<const MockWrite> writes);
+
+  StaticSocketDataProvider(const StaticSocketDataProvider&) = delete;
+  StaticSocketDataProvider& operator=(const StaticSocketDataProvider&) = delete;
+
   ~StaticSocketDataProvider() override;
 
   // Pause/resume reads from this provider.
@@ -441,8 +449,6 @@ class StaticSocketDataProvider : public SocketDataProvider {
   StaticSocketDataHelper helper_;
   SocketDataPrinter* printer_ = nullptr;
   bool paused_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
 };
 
 // ProxyClientSocketDataProvider only need to keep track of the return code from
@@ -530,6 +536,9 @@ class SequencedSocketData : public SocketDataProvider {
                       base::span<const MockRead> reads,
                       base::span<const MockWrite> writes);
 
+  SequencedSocketData(const SequencedSocketData&) = delete;
+  SequencedSocketData& operator=(const SequencedSocketData&) = delete;
+
   ~SequencedSocketData() override;
 
   // From SocketDataProvider:
@@ -569,12 +578,12 @@ class SequencedSocketData : public SocketDataProvider {
 
  private:
   // Defines the state for the read or write path.
-  enum IoState {
-    IDLE,        // No async operation is in progress.
-    PENDING,     // An async operation in waiting for another operation to
-                 // complete.
-    COMPLETING,  // A task has been posted to complete an async operation.
-    PAUSED,      // IO is paused until Resume() is called.
+  enum class IoState {
+    kIdle,        // No async operation is in progress.
+    kPending,     // An async operation in waiting for another operation to
+                  // complete.
+    kCompleting,  // A task has been posted to complete an async operation.
+    kPaused,      // IO is paused until Resume() is called.
   };
 
   // From SocketDataProvider:
@@ -598,8 +607,6 @@ class SequencedSocketData : public SocketDataProvider {
   std::unique_ptr<base::RunLoop> run_until_paused_run_loop_;
 
   base::WeakPtrFactory<SequencedSocketData> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(SequencedSocketData);
 };
 
 // Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}StreamSocket
@@ -655,6 +662,10 @@ class MockProxyClientSocket;
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory();
+
+  MockClientSocketFactory(const MockClientSocketFactory&) = delete;
+  MockClientSocketFactory& operator=(const MockClientSocketFactory&) = delete;
+
   ~MockClientSocketFactory() override;
 
   // Adds a SocketDataProvider that can be used to served either TCP or UDP
@@ -725,8 +736,6 @@ class MockClientSocketFactory : public ClientSocketFactory {
   // ERR_READ_IF_READY_NOT_IMPLEMENTED.
   bool enable_read_if_ready_;
   bool use_mock_proxy_client_sockets_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory);
 };
 
 class MockClientSocket : public TransportClientSocket {
@@ -736,6 +745,9 @@ class MockClientSocket : public TransportClientSocket {
   // unique socket IDs.
   explicit MockClientSocket(const NetLogWithSource& net_log);
 
+  MockClientSocket(const MockClientSocket&) = delete;
+  MockClientSocket& operator=(const MockClientSocket&) = delete;
+
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
@@ -783,8 +795,6 @@ class MockClientSocket : public TransportClientSocket {
 
  private:
   base::WeakPtrFactory<MockClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
@@ -792,6 +802,10 @@ class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
   MockTCPClientSocket(const AddressList& addresses,
                       net::NetLog* net_log,
                       SocketDataProvider* socket);
+
+  MockTCPClientSocket(const MockTCPClientSocket&) = delete;
+  MockTCPClientSocket& operator=(const MockTCPClientSocket&) = delete;
+
   ~MockTCPClientSocket() override;
 
   const AddressList& addresses() const { return addresses_; }
@@ -879,8 +893,6 @@ class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
   BeforeConnectCallback before_connect_callback_;
 
   ConnectionAttempts connection_attempts_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTCPClientSocket);
 };
 
 class MockProxyClientSocket : public AsyncSocket, public ProxyClientSocket {
@@ -888,6 +900,10 @@ class MockProxyClientSocket : public AsyncSocket, public ProxyClientSocket {
   MockProxyClientSocket(std::unique_ptr<StreamSocket> socket,
                         HttpAuthController* auth_controller,
                         ProxyClientSocketDataProvider* data);
+
+  MockProxyClientSocket(const MockProxyClientSocket&) = delete;
+  MockProxyClientSocket& operator=(const MockProxyClientSocket&) = delete;
+
   ~MockProxyClientSocket() override;
   // ProxyClientSocket implementation.
   const HttpResponseInfo* GetConnectResponseInfo() const override;
@@ -944,8 +960,6 @@ class MockProxyClientSocket : public AsyncSocket, public ProxyClientSocket {
   scoped_refptr<HttpAuthController> auth_controller_;
 
   base::WeakPtrFactory<MockProxyClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(MockProxyClientSocket);
 };
 
 class MockSSLClientSocket : public AsyncSocket, public SSLClientSocket {
@@ -954,6 +968,10 @@ class MockSSLClientSocket : public AsyncSocket, public SSLClientSocket {
                       const HostPortPair& host_and_port,
                       const SSLConfig& ssl_config,
                       SSLSocketDataProvider* socket);
+
+  MockSSLClientSocket(const MockSSLClientSocket&) = delete;
+  MockSSLClientSocket& operator=(const MockSSLClientSocket&) = delete;
+
   ~MockSSLClientSocket() override;
 
   // Socket implementation.
@@ -1028,14 +1046,16 @@ class MockSSLClientSocket : public AsyncSocket, public SSLClientSocket {
   IPEndPoint peer_addr_;
 
   base::WeakPtrFactory<MockSSLClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(MockSSLClientSocket);
 };
 
 class MockUDPClientSocket : public DatagramClientSocket, public AsyncSocket {
  public:
   MockUDPClientSocket(SocketDataProvider* data = nullptr,
                       net::NetLog* net_log = nullptr);
+
+  MockUDPClientSocket(const MockUDPClientSocket&) = delete;
+  MockUDPClientSocket& operator=(const MockUDPClientSocket&) = delete;
+
   ~MockUDPClientSocket() override;
 
   // Socket implementation.
@@ -1139,14 +1159,16 @@ class MockUDPClientSocket : public DatagramClientSocket, public AsyncSocket {
   bool tagged_before_data_transferred_ = true;
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
 class TestSocketRequest : public TestCompletionCallbackBase {
  public:
   TestSocketRequest(std::vector<TestSocketRequest*>* request_order,
                     size_t* completion_count);
+
+  TestSocketRequest(const TestSocketRequest&) = delete;
+  TestSocketRequest& operator=(const TestSocketRequest&) = delete;
+
   ~TestSocketRequest() override;
 
   ClientSocketHandle* handle() { return &handle_; }
@@ -1162,8 +1184,6 @@ class TestSocketRequest : public TestCompletionCallbackBase {
   ClientSocketHandle handle_;
   std::vector<TestSocketRequest*>* request_order_;
   size_t* completion_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestSocketRequest);
 };
 
 class ClientSocketPoolTest {
@@ -1179,6 +1199,10 @@ class ClientSocketPoolTest {
   static const int kRequestNotFound;
 
   ClientSocketPoolTest();
+
+  ClientSocketPoolTest(const ClientSocketPoolTest&) = delete;
+  ClientSocketPoolTest& operator=(const ClientSocketPoolTest&) = delete;
+
   ~ClientSocketPoolTest();
 
   template <typename PoolType>
@@ -1228,17 +1252,18 @@ class ClientSocketPoolTest {
   std::vector<std::unique_ptr<TestSocketRequest>> requests_;
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolTest);
 };
 
 class MockTransportSocketParams
     : public base::RefCounted<MockTransportSocketParams> {
+ public:
+  MockTransportSocketParams(const MockTransportSocketParams&) = delete;
+  MockTransportSocketParams& operator=(const MockTransportSocketParams&) =
+      delete;
+
  private:
   friend class base::RefCounted<MockTransportSocketParams>;
   ~MockTransportSocketParams() {}
-
-  DISALLOW_COPY_AND_ASSIGN(MockTransportSocketParams);
 };
 
 class MockTransportClientSocketPool : public TransportClientSocketPool {
@@ -1250,6 +1275,10 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
                    const SocketTag& socket_tag,
                    CompletionOnceCallback callback,
                    RequestPriority priority);
+
+    MockConnectJob(const MockConnectJob&) = delete;
+    MockConnectJob& operator=(const MockConnectJob&) = delete;
+
     ~MockConnectJob();
 
     int Connect();
@@ -1268,8 +1297,6 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
     const SocketTag socket_tag_;
     CompletionOnceCallback user_callback_;
     RequestPriority priority_;
-
-    DISALLOW_COPY_AND_ASSIGN(MockConnectJob);
   };
 
   MockTransportClientSocketPool(
@@ -1277,6 +1304,10 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
       int max_sockets_per_group,
       const CommonConnectJobParams* common_connect_job_params);
 
+  MockTransportClientSocketPool(const MockTransportClientSocketPool&) = delete;
+  MockTransportClientSocketPool& operator=(
+      const MockTransportClientSocketPool&) = delete;
+
   ~MockTransportClientSocketPool() override;
 
   RequestPriority last_request_priority() const {
@@ -1318,8 +1349,6 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
   RequestPriority last_request_priority_;
   int release_count_;
   int cancel_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketPool);
 };
 
 // WrappedStreamSocket is a base class that wraps an existing StreamSocket,
@@ -1376,6 +1405,10 @@ class MockTaggingStreamSocket : public WrappedStreamSocket {
  public:
   explicit MockTaggingStreamSocket(std::unique_ptr<StreamSocket> transport)
       : WrappedStreamSocket(std::move(transport)) {}
+
+  MockTaggingStreamSocket(const MockTaggingStreamSocket&) = delete;
+  MockTaggingStreamSocket& operator=(const MockTaggingStreamSocket&) = delete;
+
   ~MockTaggingStreamSocket() override {}
 
   // StreamSocket implementation.
@@ -1393,8 +1426,6 @@ class MockTaggingStreamSocket : public WrappedStreamSocket {
   bool connected_ = false;
   bool tagged_before_connected_ = true;
   SocketTag tag_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTaggingStreamSocket);
 };
 
 // Extend MockClientSocketFactory to return MockTaggingStreamSockets and
@@ -1403,6 +1434,11 @@ class MockTaggingClientSocketFactory : public MockClientSocketFactory {
  public:
   MockTaggingClientSocketFactory() = default;
 
+  MockTaggingClientSocketFactory(const MockTaggingClientSocketFactory&) =
+      delete;
+  MockTaggingClientSocketFactory& operator=(
+      const MockTaggingClientSocketFactory&) = delete;
+
   // ClientSocketFactory implementation.
   std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
@@ -1425,8 +1461,6 @@ class MockTaggingClientSocketFactory : public MockClientSocketFactory {
  private:
   MockTaggingStreamSocket* tcp_socket_ = nullptr;
   MockUDPClientSocket* udp_socket_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTaggingClientSocketFactory);
 };
 
 // Host / port used for SOCKS4 test strings.
diff --git a/chromium/net/socket/socks5_client_socket.h b/chromium/net/socket/socks5_client_socket.h
index 58f3d1285cc..55b5afcf02b 100644
--- a/chromium/net/socket/socks5_client_socket.h
+++ b/chromium/net/socket/socks5_client_socket.h
@@ -40,6 +40,9 @@ class NET_EXPORT_PRIVATE SOCKS5ClientSocket : public StreamSocket {
                      const HostPortPair& destination,
                      const NetworkTrafficAnnotationTag& traffic_annotation);
 
+  SOCKS5ClientSocket(const SOCKS5ClientSocket&) = delete;
+  SOCKS5ClientSocket& operator=(const SOCKS5ClientSocket&) = delete;
+
   // On destruction Disconnect() is called.
   ~SOCKS5ClientSocket() override;
 
@@ -158,8 +161,6 @@ class NET_EXPORT_PRIVATE SOCKS5ClientSocket : public StreamSocket {
 
   // Traffic annotation for socket control.
   NetworkTrafficAnnotationTag traffic_annotation_;
-
-  DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socks5_client_socket_unittest.cc b/chromium/net/socket/socks5_client_socket_unittest.cc
index 77cd05f82cf..e81ec66a5f3 100644
--- a/chromium/net/socket/socks5_client_socket_unittest.cc
+++ b/chromium/net/socket/socks5_client_socket_unittest.cc
@@ -47,6 +47,10 @@ namespace {
 class SOCKS5ClientSocketTest : public PlatformTest, public WithTaskEnvironment {
  public:
   SOCKS5ClientSocketTest();
+
+  SOCKS5ClientSocketTest(const SOCKS5ClientSocketTest&) = delete;
+  SOCKS5ClientSocketTest& operator=(const SOCKS5ClientSocketTest&) = delete;
+
   // Create a SOCKSClientSocket on top of a MockSocket.
   std::unique_ptr<SOCKS5ClientSocket> BuildMockSocket(
       base::span<const MockRead> reads,
@@ -67,9 +71,6 @@ class SOCKS5ClientSocketTest : public PlatformTest, public WithTaskEnvironment {
   StreamSocket* tcp_sock_;
   TestCompletionCallback callback_;
   std::unique_ptr<SocketDataProvider> data_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocketTest);
 };
 
 SOCKS5ClientSocketTest::SOCKS5ClientSocketTest()
diff --git a/chromium/net/socket/socks_client_socket.h b/chromium/net/socket/socks_client_socket.h
index 9005b12af32..0788522533b 100644
--- a/chromium/net/socket/socks_client_socket.h
+++ b/chromium/net/socket/socks_client_socket.h
@@ -42,6 +42,9 @@ class NET_EXPORT_PRIVATE SOCKSClientSocket : public StreamSocket {
                     SecureDnsPolicy secure_dns_policy,
                     const NetworkTrafficAnnotationTag& traffic_annotation);
 
+  SOCKSClientSocket(const SOCKSClientSocket&) = delete;
+  SOCKSClientSocket& operator=(const SOCKSClientSocket&) = delete;
+
   // On destruction Disconnect() is called.
   ~SOCKSClientSocket() override;
 
@@ -155,8 +158,6 @@ class NET_EXPORT_PRIVATE SOCKSClientSocket : public StreamSocket {
 
   // Traffic annotation for socket control.
   NetworkTrafficAnnotationTag traffic_annotation_;
-
-  DISALLOW_COPY_AND_ASSIGN(SOCKSClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socks_connect_job.cc b/chromium/net/socket/socks_connect_job.cc
index c5824014384..2c93200d9a2 100644
--- a/chromium/net/socket/socks_connect_job.cc
+++ b/chromium/net/socket/socks_connect_job.cc
@@ -20,8 +20,7 @@
 namespace net {
 
 // SOCKSConnectJobs will time out if the SOCKS handshake takes longer than this.
-static constexpr base::TimeDelta kSOCKSConnectJobTimeout =
-    base::TimeDelta::FromSeconds(30);
+static constexpr base::TimeDelta kSOCKSConnectJobTimeout = base::Seconds(30);
 
 SOCKSSocketParams::SOCKSSocketParams(
     scoped_refptr<TransportSocketParams> proxy_server_params,
diff --git a/chromium/net/socket/socks_connect_job.h b/chromium/net/socket/socks_connect_job.h
index 96033281646..66accbf57d2 100644
--- a/chromium/net/socket/socks_connect_job.h
+++ b/chromium/net/socket/socks_connect_job.h
@@ -35,6 +35,9 @@ class NET_EXPORT_PRIVATE SOCKSSocketParams
                     const NetworkIsolationKey& network_isolation_key,
                     const NetworkTrafficAnnotationTag& traffic_annotation);
 
+  SOCKSSocketParams(const SOCKSSocketParams&) = delete;
+  SOCKSSocketParams& operator=(const SOCKSSocketParams&) = delete;
+
   const scoped_refptr<TransportSocketParams>& transport_params() const {
     return transport_params_;
   }
@@ -60,8 +63,6 @@ class NET_EXPORT_PRIVATE SOCKSSocketParams
   const NetworkIsolationKey network_isolation_key_;
 
   NetworkTrafficAnnotationTag traffic_annotation_;
-
-  DISALLOW_COPY_AND_ASSIGN(SOCKSSocketParams);
 };
 
 // SOCKSConnectJob handles establishing a connection to a SOCKS4 or SOCKS5 proxy
@@ -89,6 +90,10 @@ class NET_EXPORT_PRIVATE SOCKSConnectJob : public ConnectJob,
                   scoped_refptr<SOCKSSocketParams> socks_params,
                   ConnectJob::Delegate* delegate,
                   const NetLogWithSource* net_log);
+
+  SOCKSConnectJob(const SOCKSConnectJob&) = delete;
+  SOCKSConnectJob& operator=(const SOCKSConnectJob&) = delete;
+
   ~SOCKSConnectJob() override;
 
   // ConnectJob methods.
@@ -140,8 +145,6 @@ class NET_EXPORT_PRIVATE SOCKSConnectJob : public ConnectJob,
   SOCKSClientSocket* socks_socket_ptr_;
 
   ResolveErrorInfo resolve_error_info_;
-
-  DISALLOW_COPY_AND_ASSIGN(SOCKSConnectJob);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/socks_connect_job_unittest.cc b/chromium/net/socket/socks_connect_job_unittest.cc
index c5c87f5116a..6945188bb62 100644
--- a/chromium/net/socket/socks_connect_job_unittest.cc
+++ b/chromium/net/socket/socks_connect_job_unittest.cc
@@ -38,7 +38,7 @@ namespace {
 const char kProxyHostName[] = "proxy.test";
 const int kProxyPort = 4321;
 
-constexpr base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+constexpr base::TimeDelta kTinyTime = base::Microseconds(1);
 
 class SOCKSConnectJobTest : public testing::Test, public WithTaskEnvironment {
  public:
diff --git a/chromium/net/socket/ssl_client_socket.h b/chromium/net/socket/ssl_client_socket.h
index 0f0fe9a36df..c1e41ed2022 100644
--- a/chromium/net/socket/ssl_client_socket.h
+++ b/chromium/net/socket/ssl_client_socket.h
@@ -66,7 +66,7 @@ class NET_EXPORT SSLClientSocket : public SSLSocket {
  private:
   FRIEND_TEST_ALL_PREFIXES(SSLClientSocket, SerializeNextProtos);
   // For signed_cert_timestamps_received_ and stapled_ocsp_response_received_.
-  FRIEND_TEST_ALL_PREFIXES(SSLClientSocketTest,
+  FRIEND_TEST_ALL_PREFIXES(SSLClientSocketVersionTest,
                            ConnectSignedCertTimestampsTLSExtension);
   FRIEND_TEST_ALL_PREFIXES(SSLClientSocketVersionTest,
                            ConnectSignedCertTimestampsEnablesOCSP);
@@ -105,6 +105,10 @@ class NET_EXPORT SSLClientContext : public SSLConfigService::Observer,
                    CTPolicyEnforcer* ct_policy_enforcer,
                    SSLClientSessionCache* ssl_client_session_cache,
                    SCTAuditingDelegate* sct_auditing_delegate);
+
+  SSLClientContext(const SSLClientContext&) = delete;
+  SSLClientContext& operator=(const SSLClientContext&) = delete;
+
   ~SSLClientContext() override;
 
   const SSLContextConfig& config() { return config_; }
@@ -188,8 +192,6 @@ class NET_EXPORT SSLClientContext : public SSLConfigService::Observer,
   SSLClientAuthCache ssl_client_auth_cache_;
 
   base::ObserverList<Observer, true /* check_empty */> observers_;
-
-  DISALLOW_COPY_AND_ASSIGN(SSLClientContext);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/ssl_client_socket_impl.cc b/chromium/net/socket/ssl_client_socket_impl.cc
index 62672bfa326..f6ba90328bb 100644
--- a/chromium/net/socket/ssl_client_socket_impl.cc
+++ b/chromium/net/socket/ssl_client_socket_impl.cc
@@ -584,6 +584,7 @@ bool SSLClientSocketImpl::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->pkp_bypassed = pkp_bypassed_;
   ssl_info->public_key_hashes = server_cert_verify_result_.public_key_hashes;
   ssl_info->client_cert_sent = send_client_cert_ && client_cert_.get();
+  ssl_info->encrypted_client_hello = SSL_ech_accepted(ssl_.get());
   ssl_info->pinning_failure_log = pinning_failure_log_;
   ssl_info->ocsp_result = server_cert_verify_result_.ocsp_result;
   ssl_info->is_fatal_cert_error = is_fatal_cert_error_;
@@ -618,20 +619,6 @@ int64_t SSLClientSocketImpl::GetTotalReceivedBytes() const {
   return stream_socket_->GetTotalReceivedBytes();
 }
 
-void SSLClientSocketImpl::DumpMemoryStats(SocketMemoryStats* stats) const {
-  if (transport_adapter_)
-    stats->buffer_size = transport_adapter_->GetAllocationSize();
-  const STACK_OF(CRYPTO_BUFFER)* server_cert_chain =
-      SSL_get0_peer_certificates(ssl_.get());
-  if (server_cert_chain) {
-    for (const CRYPTO_BUFFER* cert : server_cert_chain) {
-      stats->cert_size += CRYPTO_BUFFER_len(cert);
-    }
-    stats->cert_count = sk_CRYPTO_BUFFER_num(server_cert_chain);
-  }
-  stats->total_size = stats->buffer_size + stats->cert_size;
-}
-
 void SSLClientSocketImpl::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) const {
   if (!ssl_) {
@@ -925,6 +912,21 @@ int SSLClientSocketImpl::Init() {
         host_and_port_, &client_cert_, &client_private_key_);
   }
 
+  // TODO(https://crbug.com/1091403): Also enable ECH GREASE, gated on SSLConfig
+  // or a base::Feature, for when we don't have an ECHConfig.
+  if (!ssl_config_.ech_config_list.empty()) {
+    net_log_.AddEvent(NetLogEventType::SSL_ECH_CONFIG_LIST, [&] {
+      base::Value dict(base::Value::Type::DICTIONARY);
+      dict.SetKey("bytes", NetLogBinaryValue(ssl_config_.ech_config_list));
+      return dict;
+    });
+    if (!SSL_set1_ech_config_list(ssl_.get(),
+                                  ssl_config_.ech_config_list.data(),
+                                  ssl_config_.ech_config_list.size())) {
+      return ERR_INVALID_ECH_CONFIG_LIST;
+    }
+  }
+
   return OK;
 }
 
@@ -1115,6 +1117,18 @@ ssl_verify_result_t SSLClientSocketImpl::VerifyCert() {
     return HandleVerifyResult();
   }
 
+  // TODO(crbug.com/1091403): Implement the recovery flow.
+  const char* ech_name_override;
+  size_t ech_name_override_len;
+  SSL_get0_ech_name_override(ssl_.get(), &ech_name_override,
+                             &ech_name_override_len);
+  if (ech_name_override_len > 0) {
+    DCHECK(!ssl_config_.ech_config_list.empty());
+    NOTIMPLEMENTED();
+    OpenSSLPutNetError(FROM_HERE, ERR_FAILED);
+    return ssl_verify_invalid;
+  }
+
   // In this configuration, BoringSSL will perform exactly one certificate
   // verification, so there cannot be state from a previous verification.
   CHECK(!server_cert_);
diff --git a/chromium/net/socket/ssl_client_socket_impl.h b/chromium/net/socket/ssl_client_socket_impl.h
index 83e51290929..85ac408b7d0 100644
--- a/chromium/net/socket/ssl_client_socket_impl.h
+++ b/chromium/net/socket/ssl_client_socket_impl.h
@@ -59,6 +59,10 @@ class SSLClientSocketImpl : public SSLClientSocket,
                       std::unique_ptr<StreamSocket> stream_socket,
                       const HostPortPair& host_and_port,
                       const SSLConfig& ssl_config);
+
+  SSLClientSocketImpl(const SSLClientSocketImpl&) = delete;
+  SSLClientSocketImpl& operator=(const SSLClientSocketImpl&) = delete;
+
   ~SSLClientSocketImpl() override;
 
   const HostPortPair& host_and_port() const { return host_and_port_; }
@@ -92,7 +96,6 @@ class SSLClientSocketImpl : public SSLClientSocket,
   void ClearConnectionAttempts() override {}
   void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
   int64_t GetTotalReceivedBytes() const override;
-  void DumpMemoryStats(SocketMemoryStats* stats) const override;
   void GetSSLCertRequestInfo(
       SSLCertRequestInfo* cert_request_info) const override;
 
@@ -302,8 +305,6 @@ class SSLClientSocketImpl : public SSLClientSocket,
 
   NetLogWithSource net_log_;
   base::WeakPtrFactory<SSLClientSocketImpl> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(SSLClientSocketImpl);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/ssl_client_socket_unittest.cc b/chromium/net/socket/ssl_client_socket_unittest.cc
index b31b2ed9abf..03d284bb8ef 100644
--- a/chromium/net/socket/ssl_client_socket_unittest.cc
+++ b/chromium/net/socket/ssl_client_socket_unittest.cc
@@ -21,8 +21,10 @@
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
+#include "base/synchronization/lock.h"
 #include "base/test/bind.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
@@ -96,6 +98,7 @@
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "third_party/boringssl/src/include/openssl/bio.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
+#include "third_party/boringssl/src/include/openssl/hpke.h"
 #include "third_party/boringssl/src/include/openssl/pem.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "url/gurl.h"
@@ -141,6 +144,11 @@ class SynchronousErrorStreamSocket : public WrappedStreamSocket {
  public:
   explicit SynchronousErrorStreamSocket(std::unique_ptr<StreamSocket> transport)
       : WrappedStreamSocket(std::move(transport)) {}
+
+  SynchronousErrorStreamSocket(const SynchronousErrorStreamSocket&) = delete;
+  SynchronousErrorStreamSocket& operator=(const SynchronousErrorStreamSocket&) =
+      delete;
+
   ~SynchronousErrorStreamSocket() override = default;
 
   // Socket implementation:
@@ -181,8 +189,6 @@ class SynchronousErrorStreamSocket : public WrappedStreamSocket {
 
   bool have_write_error_ = false;
   int pending_write_error_ = OK;
-
-  DISALLOW_COPY_AND_ASSIGN(SynchronousErrorStreamSocket);
 };
 
 int SynchronousErrorStreamSocket::Read(IOBuffer* buf,
@@ -558,6 +564,10 @@ class CountingStreamSocket : public WrappedStreamSocket {
 class DeleteSocketCallback : public TestCompletionCallbackBase {
  public:
   explicit DeleteSocketCallback(StreamSocket* socket) : socket_(socket) {}
+
+  DeleteSocketCallback(const DeleteSocketCallback&) = delete;
+  DeleteSocketCallback& operator=(const DeleteSocketCallback&) = delete;
+
   ~DeleteSocketCallback() override = default;
 
   CompletionOnceCallback callback() {
@@ -577,8 +587,6 @@ class DeleteSocketCallback : public TestCompletionCallbackBase {
   }
 
   StreamSocket* socket_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeleteSocketCallback);
 };
 
 // A mock ExpectCTReporter that remembers the latest violation that was
@@ -689,33 +697,34 @@ class ManySmallRecordsHttpResponse : public test_server::HttpResponse {
   ManySmallRecordsHttpResponse(size_t chunk_size, size_t chunk_count)
       : chunk_size_(chunk_size), chunk_count_(chunk_count) {}
 
-  void SendResponse(const test_server::SendBytesCallback& send,
-                    test_server::SendCompleteCallback done) override {
-    std::string headers = base::StringPrintf(
-        "HTTP/1.1 200 OK\r\n"
-        "Connection: close\r\n"
-        "Content-Length: %zu\r\n"
-        "Content-Type: text/plain\r\n\r\n",
-        chunk_size_ * chunk_count_);
-    send.Run(headers, base::BindOnce(&SendChunks, chunk_size_, chunk_count_,
-                                     send, std::move(done)));
+  void SendResponse(
+      base::WeakPtr<test_server::HttpResponseDelegate> delegate) override {
+    base::StringPairs headers = {
+        {"Connection", "close"},
+        {"Content-Length", base::NumberToString(chunk_size_ * chunk_count_)},
+        {"Content-Type", "text/plain"}};
+    delegate->SendResponseHeaders(HTTP_OK, "OK", headers);
+    SendChunks(chunk_size_, chunk_count_, delegate);
   }
 
  private:
-  static void SendChunks(size_t chunk_size,
-                         size_t chunk_count,
-                         const test_server::SendBytesCallback& send,
-                         test_server::SendCompleteCallback done) {
+  static void SendChunks(
+      size_t chunk_size,
+      size_t chunk_count,
+      base::WeakPtr<test_server::HttpResponseDelegate> delegate) {
+    if (!delegate)
+      return;
+
     if (chunk_count == 0) {
-      std::move(done).Run();
+      delegate->FinishResponse();
       return;
     }
 
     std::string chunk(chunk_size, '*');
     // This assumes that splitting output into separate |send| calls will
     // produce separate TLS records.
-    send.Run(chunk, base::BindOnce(&SendChunks, chunk_size, chunk_count - 1,
-                                   send, std::move(done)));
+    delegate->SendContents(chunk, base::BindOnce(&SendChunks, chunk_size,
+                                                 chunk_count - 1, delegate));
   }
 
   size_t chunk_size_;
@@ -810,6 +819,8 @@ class SSLClientSocketTest : public PlatformTest, public WithTaskEnvironment {
     server->AddDefaultHandlers(base::FilePath());
     server->RegisterRequestHandler(
         base::BindRepeating(&ManySmallRecordsHttpResponse::HandleRequest));
+    server->RegisterRequestHandler(
+        base::BindRepeating(&HandleSSLInfoRequest, base::Unretained(this)));
   }
 
   // Starts the spawned test server with SSL configuration |ssl_options|.
@@ -896,6 +907,15 @@ class SSLClientSocketTest : public PlatformTest, public WithTaskEnvironment {
     cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
   }
 
+  absl::optional<SSLInfo> LastSSLInfoFromServer() {
+    // EmbeddedTestServer callbacks run on another thread, so protect this
+    // with a lock.
+    base::AutoLock lock(server_ssl_info_lock_);
+    auto result = server_ssl_info_;
+    server_ssl_info_ = absl::nullopt;
+    return result;
+  }
+
   RecordingTestNetLog log_;
   ClientSocketFactory* socket_factory_;
   std::unique_ptr<TestSSLConfigService> ssl_config_service_;
@@ -907,8 +927,25 @@ class SSLClientSocketTest : public PlatformTest, public WithTaskEnvironment {
   std::unique_ptr<SSLClientSocket> sock_;
 
  private:
+  static std::unique_ptr<test_server::HttpResponse> HandleSSLInfoRequest(
+      SSLClientSocketTest* test,
+      const test_server::HttpRequest& request) {
+    if (request.relative_url != "/ssl-info") {
+      return nullptr;
+    }
+    {
+      // EmbeddedTestServer callbacks run on another thread, so protect this
+      // with a lock.
+      base::AutoLock lock(test->server_ssl_info_lock_);
+      test->server_ssl_info_ = request.ssl_info;
+    }
+    return std::make_unique<test_server::BasicHttpResponse>();
+  }
+
   std::unique_ptr<SpawnedTestServer> spawned_test_server_;
   std::unique_ptr<EmbeddedTestServer> embedded_test_server_;
+  base::Lock server_ssl_info_lock_;
+  absl::optional<SSLInfo> server_ssl_info_ GUARDED_BY(server_ssl_info_lock_);
   TestCompletionCallback callback_;
   AddressList addr_;
   HostPortPair host_port_pair_;
@@ -1269,8 +1306,8 @@ class SSLClientSocketFalseStartTest : public SSLClientSocketTest {
 
 // Sends an HTTP request on the socket and reads the response. This may be used
 // to ensure some data has been consumed from the server.
-int MakeHTTPRequest(StreamSocket* socket) {
-  base::StringPiece request = "GET / HTTP/1.0\r\n\r\n";
+int MakeHTTPRequest(StreamSocket* socket, const char* path = "/") {
+  std::string request = base::StringPrintf("GET %s HTTP/1.0\r\n\r\n", path);
   TestCompletionCallback callback;
   while (!request.empty()) {
     auto request_buffer =
@@ -1298,10 +1335,14 @@ int MakeHTTPRequest(StreamSocket* socket) {
 class ZeroRTTResponse : public test_server::HttpResponse {
  public:
   ZeroRTTResponse(bool zero_rtt) : zero_rtt_(zero_rtt) {}
+
+  ZeroRTTResponse(const ZeroRTTResponse&) = delete;
+  ZeroRTTResponse& operator=(const ZeroRTTResponse&) = delete;
+
   ~ZeroRTTResponse() override {}
 
-  void SendResponse(const test_server::SendBytesCallback& send,
-                    test_server::SendCompleteCallback done) override {
+  void SendResponse(
+      base::WeakPtr<test_server::HttpResponseDelegate> delegate) override {
     std::string response;
     if (zero_rtt_) {
       response = "1";
@@ -1312,27 +1353,20 @@ class ZeroRTTResponse : public test_server::HttpResponse {
     // Since the EmbeddedTestServer doesn't keep the socket open by default, it
     // is explicitly kept alive to allow the remaining leg of the 0RTT handshake
     // to be received after the early data.
-    send.Run(response, base::BindOnce([]() {}));
+    delegate->SendContents(response);
   }
 
  private:
   bool zero_rtt_;
-
-  DISALLOW_COPY_AND_ASSIGN(ZeroRTTResponse);
 };
 
 std::unique_ptr<test_server::HttpResponse> HandleZeroRTTRequest(
     const test_server::HttpRequest& request) {
-  if (request.GetURL().path() != "/zerortt")
+  if (request.GetURL().path() != "/zerortt" || !request.ssl_info)
     return nullptr;
-  bool zero_rtt = false;
-  if (request.headers.find("Early-Data") != request.headers.end()) {
-    if (request.headers.at("Early-Data") == "1") {
-      zero_rtt = true;
-    }
-  }
 
-  return std::make_unique<ZeroRTTResponse>(zero_rtt);
+  return std::make_unique<ZeroRTTResponse>(
+      request.ssl_info->early_data_received);
 }
 
 class SSLClientSocketZeroRTTTest : public SSLClientSocketTest {
@@ -1493,6 +1527,41 @@ class HangingCertVerifier : public CertVerifier {
   int num_active_requests_ = 0;
 };
 
+bssl::UniquePtr<SSL_ECH_KEYS> MakeTestECHKeys(
+    const char* public_name,
+    size_t max_name_len,
+    std::vector<uint8_t>* ech_config_list) {
+  bssl::ScopedEVP_HPKE_KEY key;
+  if (!EVP_HPKE_KEY_generate(key.get(), EVP_hpke_x25519_hkdf_sha256())) {
+    return nullptr;
+  }
+
+  uint8_t* ech_config;
+  size_t ech_config_len;
+  if (!SSL_marshal_ech_config(&ech_config, &ech_config_len,
+                              /*config_id=*/1, key.get(), public_name,
+                              max_name_len)) {
+    return nullptr;
+  }
+  bssl::UniquePtr<uint8_t> scoped_ech_config(ech_config);
+
+  uint8_t* ech_config_list_raw;
+  size_t ech_config_list_len;
+  bssl::UniquePtr<SSL_ECH_KEYS> keys(SSL_ECH_KEYS_new());
+  if (!keys ||
+      !SSL_ECH_KEYS_add(keys.get(), /*is_retry_config=*/1, ech_config,
+                        ech_config_len, key.get()) ||
+      !SSL_ECH_KEYS_marshal_retry_configs(keys.get(), &ech_config_list_raw,
+                                          &ech_config_list_len)) {
+    return nullptr;
+  }
+  bssl::UniquePtr<uint8_t> scoped_ech_config_list(ech_config_list_raw);
+
+  ech_config_list->assign(ech_config_list_raw,
+                          ech_config_list_raw + ech_config_list_len);
+  return keys;
+}
+
 }  // namespace
 
 INSTANTIATE_TEST_SUITE_P(TLSVersion,
@@ -1950,7 +2019,7 @@ TEST_P(SSLClientSocketVersionTest, Write_WithSynchronousErrorNoRead) {
   int old_write_count = raw_counting_socket->write_count();
   base::RunLoop loop;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, loop.QuitClosure(), base::TimeDelta::FromMilliseconds(100));
+      FROM_HERE, loop.QuitClosure(), base::Milliseconds(100));
   loop.Run();
   EXPECT_EQ(old_write_count, raw_counting_socket->write_count());
 }
@@ -2812,13 +2881,15 @@ TEST_P(SSLClientSocketCertRequestInfoTest, CertKeyTypes) {
 
 // Tests that the Certificate Transparency (RFC 6962) TLS extension is
 // supported.
-TEST_F(SSLClientSocketTest, ConnectSignedCertTimestampsTLSExtension) {
+TEST_P(SSLClientSocketVersionTest, ConnectSignedCertTimestampsTLSExtension) {
   // Encoding of SCT List containing 'test'.
   base::StringPiece sct_ext("\x00\x06\x00\x04test", 8);
 
-  SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.signed_cert_timestamps_tls_ext = std::string(sct_ext);
-  ASSERT_TRUE(StartTestServer(ssl_options));
+  SSLServerConfig server_config = GetServerConfig();
+  server_config.signed_cert_timestamp_list =
+      std::vector<uint8_t>(sct_ext.begin(), sct_ext.end());
+  ASSERT_TRUE(
+      StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
 
   auto ct_verifier = std::make_unique<MockCTVerifier>();
 
@@ -3050,8 +3121,7 @@ TEST_P(SSLClientSocketVersionTest, IsFatalErrorSetOnFatalError) {
   ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_CHAIN_WRONG_ROOT,
                                       GetServerConfig()));
   int rv;
-  const base::Time expiry =
-      base::Time::Now() + base::TimeDelta::FromSeconds(1000);
+  const base::Time expiry = base::Time::Now() + base::Seconds(1000);
   transport_security_state_->AddHSTS(host_port_pair().host(), expiry, true);
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
   SSLInfo ssl_info;
@@ -3418,19 +3488,6 @@ TEST_P(SSLClientSocketVersionTest, CertificateErrorNoResume) {
   EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
 }
 
-// Test that DHE is removed.
-TEST_F(SSLClientSocketTest, NoDHE) {
-  SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.key_exchanges =
-      SpawnedTestServer::SSLOptions::KEY_EXCHANGE_DHE_RSA;
-  ASSERT_TRUE(StartTestServer(ssl_options));
-
-  SSLConfig ssl_config;
-  int rv;
-  ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
-  EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
-}
-
 TEST_F(SSLClientSocketTest, RequireECDHE) {
   // Run test server without ECDHE.
   SSLServerConfig server_config;
@@ -4237,7 +4294,7 @@ TEST_P(SSLClientSocketVersionTest, CTRequiredHistogramCompliant) {
 
   // Set up the Expect-CT opt-in.
   const base::Time current_time(base::Time::Now());
-  const base::Time expiry = current_time + base::TimeDelta::FromSeconds(1000);
+  const base::Time expiry = current_time + base::Seconds(1000);
   transport_security_state_->AddExpectCT(
       host_port_pair().host(), expiry, true /* enforce */,
       GURL("https://example-report.test"), NetworkIsolationKey());
@@ -4322,7 +4379,7 @@ TEST_P(SSLClientSocketVersionTest, CTRequiredHistogramNonCompliant) {
 
   // Set up the Expect-CT opt-in.
   const base::Time current_time(base::Time::Now());
-  const base::Time expiry = current_time + base::TimeDelta::FromSeconds(1000);
+  const base::Time expiry = current_time + base::Seconds(1000);
   transport_security_state_->AddExpectCT(
       host_port_pair().host(), expiry, true /* enforce */,
       GURL("https://example-report.test"), NetworkIsolationKey());
@@ -4418,7 +4475,7 @@ TEST_P(SSLClientSocketVersionTest, CTIsRequiredByExpectCT) {
   NetworkIsolationKey network_isolation_key =
       NetworkIsolationKey::CreateTransient();
   const base::Time current_time(base::Time::Now());
-  const base::Time expiry = current_time + base::TimeDelta::FromSeconds(1000);
+  const base::Time expiry = current_time + base::Seconds(1000);
   transport_security_state_->AddExpectCT(
       host_port_pair().host(), expiry, true /* enforce */,
       GURL("https://example-report.test"), network_isolation_key);
@@ -5295,51 +5352,6 @@ TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTParallelReadConfirm) {
   EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
 }
 
-// Basic test for dumping memory stats.
-TEST_P(SSLClientSocketReadTest, DumpMemoryStats) {
-  ASSERT_TRUE(
-      StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
-
-  // This test compares the memory usage when there is and isn't a pending read
-  // on the socket, so disable the post-handshake peek.
-  SSLConfig config;
-  config.disable_post_handshake_peek_for_testing = true;
-
-  int rv;
-  ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
-  EXPECT_THAT(rv, IsOk());
-  StreamSocket::SocketMemoryStats stats;
-  sock_->DumpMemoryStats(&stats);
-  EXPECT_EQ(0u, stats.buffer_size);
-  EXPECT_EQ(1u, stats.cert_count);
-  EXPECT_LT(0u, stats.cert_size);
-  EXPECT_EQ(stats.cert_size, stats.total_size);
-
-  // Read the response without writing a request, so the read will be pending.
-  TestCompletionCallback read_callback;
-  scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
-  rv = Read(sock_.get(), buf.get(), 4096, read_callback.callback());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-
-  // Dump memory again and check that |buffer_size| contain the read buffer.
-  StreamSocket::SocketMemoryStats stats2;
-  sock_->DumpMemoryStats(&stats2);
-
-  if (read_if_ready_supported()) {
-    EXPECT_EQ(0u, stats2.buffer_size);
-    EXPECT_EQ(stats.cert_size, stats2.total_size);
-  } else {
-    EXPECT_EQ(17 * 1024u, stats2.buffer_size);
-    EXPECT_LT(17 * 1024u, stats2.total_size);
-  }
-  EXPECT_EQ(1u, stats2.cert_count);
-  EXPECT_LT(0u, stats2.cert_size);
-
-  // Drop the socket. It has a pending read with a reference to |read_callback|,
-  // so the socket must be dropped before the test returns.
-  sock_ = nullptr;
-}
-
 TEST_P(SSLClientSocketReadTest, IdleAfterRead) {
   // Set up a TCP server.
   TCPServerSocket server_listener(nullptr, NetLogSource());
@@ -5407,14 +5419,6 @@ TEST_P(SSLClientSocketReadTest, IdleAfterRead) {
 
   // At this point the client socket should be idle.
   EXPECT_TRUE(client->IsConnectedAndIdle());
-
-  // The read buffer should be released.
-  StreamSocket::SocketMemoryStats stats;
-  client->DumpMemoryStats(&stats);
-  EXPECT_EQ(0u, stats.buffer_size);
-  EXPECT_EQ(1u, stats.cert_count);
-  EXPECT_LT(0u, stats.cert_size);
-  EXPECT_EQ(stats.cert_size, stats.total_size);
 }
 
 // Test that certificate errors are properly reported when the underlying
@@ -5540,6 +5544,100 @@ TEST_F(SSLClientSocketTest, Tag) {
 #endif  // OS_ANDROID
 }
 
+TEST_F(SSLClientSocketTest, ECH) {
+  SSLServerConfig server_config;
+  SSLConfig client_config;
+  server_config.ech_keys = MakeTestECHKeys(
+      "public.example", /*max_name_len=*/64, &client_config.ech_config_list);
+  ASSERT_TRUE(server_config.ech_keys);
+
+  ASSERT_TRUE(
+      StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
+
+  // Connecting with the client should use ECH.
+  int rv;
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
+  EXPECT_THAT(rv, IsOk());
+  SSLInfo ssl_info;
+  ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
+  EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
+  EXPECT_TRUE(ssl_info.encrypted_client_hello);
+
+  // TLS 1.3 causes the ticket to arrive later. Use the socket to ensure we have
+  // a ticket. This also populates the SSLInfo from the server.
+  EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
+  absl::optional<SSLInfo> server_ssl_info = LastSSLInfoFromServer();
+  ASSERT_TRUE(server_ssl_info);
+  EXPECT_TRUE(server_ssl_info->encrypted_client_hello);
+
+  // Reconnect. ECH should not interfere with resumption.
+  sock_.reset();
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
+  EXPECT_THAT(rv, IsOk());
+  ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
+  EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
+  EXPECT_TRUE(ssl_info.encrypted_client_hello);
+
+  // Check SSLInfo from the server.
+  EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
+  server_ssl_info = LastSSLInfoFromServer();
+  ASSERT_TRUE(server_ssl_info);
+  EXPECT_TRUE(server_ssl_info->encrypted_client_hello);
+
+  // Connecting without ECH should not report ECH was used.
+  client_config.ech_config_list.clear();
+  sock_.reset();
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
+  EXPECT_THAT(rv, IsOk());
+  ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
+  EXPECT_FALSE(ssl_info.encrypted_client_hello);
+
+  // Check SSLInfo from the server.
+  EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
+  server_ssl_info = LastSSLInfoFromServer();
+  ASSERT_TRUE(server_ssl_info);
+  EXPECT_FALSE(server_ssl_info->encrypted_client_hello);
+}
+
+TEST_F(SSLClientSocketTest, ECHWrongKeys) {
+  std::vector<uint8_t> ech_config_list1, ech_config_list2;
+  bssl::UniquePtr<SSL_ECH_KEYS> keys1 =
+      MakeTestECHKeys("public.example", /*max_name_len=*/64, &ech_config_list1);
+  ASSERT_TRUE(keys1);
+  bssl::UniquePtr<SSL_ECH_KEYS> keys2 =
+      MakeTestECHKeys("public.example", /*max_name_len=*/64, &ech_config_list2);
+  ASSERT_TRUE(keys2);
+
+  // Configure the client and server with different keys.
+  SSLServerConfig server_config;
+  server_config.ech_keys = std::move(keys1);
+  SSLConfig client_config;
+  client_config.ech_config_list = std::move(ech_config_list2);
+
+  ASSERT_TRUE(
+      StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
+
+  // Connecting with the client should use ECH.
+  int rv;
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
+  // TODO(crbug.com/1091403): Implement the recovery flow. Test that this both
+  // verifies against the public name and exposes retry configs.
+  EXPECT_THAT(rv, IsError(ERR_FAILED));
+}
+
+TEST_F(SSLClientSocketTest, InvalidECHConfigList) {
+  ASSERT_TRUE(
+      StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
+
+  // If the ECHConfigList cannot be parsed at all, report an error to the
+  // caller.
+  SSLConfig client_config;
+  client_config.ech_config_list = {0x00};
+  int rv;
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
+  EXPECT_THAT(rv, IsError(ERR_INVALID_ECH_CONFIG_LIST));
+}
+
 class TLS13DowngradeTest
     : public SSLClientSocketTest,
       public ::testing::WithParamInterface<
@@ -5873,8 +5971,7 @@ TEST_F(LegacyTLSDeprecationTest, LegacyTLSErrorsNotFatal) {
   // Connection should fail with ERR_SSL_OBSOLETE_VERSION and the legacy TLS
   // cert status.
   int rv;
-  const base::Time expiry =
-      base::Time::Now() + base::TimeDelta::FromSeconds(1000);
+  const base::Time expiry = base::Time::Now() + base::Seconds(1000);
   transport_security_state_->AddHSTS(host_port_pair().host(), expiry, true);
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
   EXPECT_THAT(rv, IsError(ERR_SSL_OBSOLETE_VERSION));
@@ -5929,7 +6026,8 @@ TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonNoResume) {
 }
 
 // Test 0-RTT logging in the standard ConfirmHandshake-after-acceptance case.
-TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonZeroRTT) {
+// Disabled due to flakiness across all platforms: https://crbug.com/1247914.
+TEST_F(SSLClientSocketZeroRTTTest, DISABLED_EarlyDataReasonZeroRTT) {
   const char kReasonHistogram[] = "Net.SSLHandshakeEarlyDataReason";
 
   ASSERT_TRUE(StartServer());
diff --git a/chromium/net/socket/ssl_connect_job.cc b/chromium/net/socket/ssl_connect_job.cc
index 18791fc03a0..935e68733dd 100644
--- a/chromium/net/socket/ssl_connect_job.cc
+++ b/chromium/net/socket/ssl_connect_job.cc
@@ -41,8 +41,7 @@ namespace net {
 namespace {
 
 // Timeout for the SSL handshake portion of the connect.
-constexpr base::TimeDelta kSSLHandshakeTimeout(
-    base::TimeDelta::FromSeconds(30));
+constexpr base::TimeDelta kSSLHandshakeTimeout(base::Seconds(30));
 
 }  // namespace
 
@@ -422,8 +421,7 @@ int SSLConnectJob::DoSSLConnectComplete(int result) {
     base::TimeDelta connect_duration =
         connect_timing_.ssl_end - connect_timing_.ssl_start;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_2", connect_duration,
-                               base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMinutes(1), 100);
+                               base::Milliseconds(1), base::Minutes(1), 100);
 
     SSLInfo ssl_info;
     bool has_ssl_info = ssl_socket_->GetSSLInfo(&ssl_info);
diff --git a/chromium/net/socket/ssl_connect_job.h b/chromium/net/socket/ssl_connect_job.h
index 40cd4d8560c..4563f239223 100644
--- a/chromium/net/socket/ssl_connect_job.h
+++ b/chromium/net/socket/ssl_connect_job.h
@@ -47,6 +47,9 @@ class NET_EXPORT_PRIVATE SSLSocketParams
                   PrivacyMode privacy_mode,
                   NetworkIsolationKey network_isolation_key);
 
+  SSLSocketParams(const SSLSocketParams&) = delete;
+  SSLSocketParams& operator=(const SSLSocketParams&) = delete;
+
   // Returns the type of the underlying connection.
   ConnectionType GetConnectionType() const;
 
@@ -78,8 +81,6 @@ class NET_EXPORT_PRIVATE SSLSocketParams
   const SSLConfig ssl_config_;
   const PrivacyMode privacy_mode_;
   const NetworkIsolationKey network_isolation_key_;
-
-  DISALLOW_COPY_AND_ASSIGN(SSLSocketParams);
 };
 
 // SSLConnectJob establishes a connection, through a proxy if needed, and then
@@ -109,6 +110,10 @@ class NET_EXPORT_PRIVATE SSLConnectJob : public ConnectJob,
                 scoped_refptr<SSLSocketParams> params,
                 ConnectJob::Delegate* delegate,
                 const NetLogWithSource* net_log);
+
+  SSLConnectJob(const SSLConnectJob&) = delete;
+  SSLConnectJob& operator=(const SSLConnectJob&) = delete;
+
   ~SSLConnectJob() override;
 
   // ConnectJob methods.
@@ -201,8 +206,6 @@ class NET_EXPORT_PRIVATE SSLConnectJob : public ConnectJob,
   // limited lifetime and the aliases can no longer be retrieved from there by
   // by the time that the aliases are needed to be passed in SetSocket.
   std::vector<std::string> dns_aliases_;
-
-  DISALLOW_COPY_AND_ASSIGN(SSLConnectJob);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/ssl_connect_job_unittest.cc b/chromium/net/socket/ssl_connect_job_unittest.cc
index 118df885dd7..b8310ff87e7 100644
--- a/chromium/net/socket/ssl_connect_job_unittest.cc
+++ b/chromium/net/socket/ssl_connect_job_unittest.cc
@@ -211,7 +211,7 @@ TEST_F(SSLConnectJobTest, TCPFail) {
 }
 
 TEST_F(SSLConnectJobTest, TCPTimeout) {
-  const base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+  const base::TimeDelta kTinyTime = base::Microseconds(1);
 
   // Make request hang.
   host_resolver_.set_ondemand_mode(true);
@@ -233,7 +233,7 @@ TEST_F(SSLConnectJobTest, TCPTimeout) {
 }
 
 TEST_F(SSLConnectJobTest, SSLTimeoutSyncConnect) {
-  const base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+  const base::TimeDelta kTinyTime = base::Microseconds(1);
 
   // DNS lookup and transport connect complete synchronously, but SSL
   // negotiation hangs.
@@ -262,7 +262,7 @@ TEST_F(SSLConnectJobTest, SSLTimeoutSyncConnect) {
 }
 
 TEST_F(SSLConnectJobTest, SSLTimeoutAsyncTcpConnect) {
-  const base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+  const base::TimeDelta kTinyTime = base::Microseconds(1);
 
   // DNS lookup is asynchronous, and later SSL negotiation hangs.
   host_resolver_.set_ondemand_mode(true);
@@ -337,7 +337,7 @@ TEST_F(SSLConnectJobTest, BasicDirectAsync) {
   EXPECT_THAT(ssl_connect_job->Connect(), test::IsError(ERR_IO_PENDING));
   EXPECT_TRUE(host_resolver_.has_pending_requests());
   EXPECT_EQ(MEDIUM, host_resolver_.last_request_priority());
-  FastForwardBy(base::TimeDelta::FromSeconds(5));
+  FastForwardBy(base::Seconds(5));
 
   base::TimeTicks resolve_complete_time = base::TimeTicks::Now();
   host_resolver_.ResolveAllPending();
@@ -959,7 +959,7 @@ TEST_F(SSLConnectJobTest, HttpProxyAuthChallenge) {
 
   // While waiting for auth credentials to be provided, the Job should not time
   // out.
-  FastForwardBy(base::TimeDelta::FromDays(1));
+  FastForwardBy(base::Days(1));
   test_delegate.WaitForAuthChallenge(1);
   EXPECT_FALSE(test_delegate.has_result());
 
diff --git a/chromium/net/socket/ssl_server_socket_impl.cc b/chromium/net/socket/ssl_server_socket_impl.cc
index 2b63812e48d..4bed18d6b9e 100644
--- a/chromium/net/socket/ssl_server_socket_impl.cc
+++ b/chromium/net/socket/ssl_server_socket_impl.cc
@@ -71,6 +71,10 @@ class SSLServerContextImpl::SocketImpl : public SSLServerSocket,
  public:
   SocketImpl(SSLServerContextImpl* context,
              std::unique_ptr<StreamSocket> socket);
+
+  SocketImpl(const SocketImpl&) = delete;
+  SocketImpl& operator=(const SocketImpl&) = delete;
+
   ~SocketImpl() override;
 
   // SSLServerSocket interface.
@@ -220,8 +224,6 @@ class SSLServerContextImpl::SocketImpl : public SSLServerSocket,
   NextProto negotiated_protocol_;
 
   base::WeakPtrFactory<SocketImpl> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(SocketImpl);
 };
 
 SSLServerContextImpl::SocketImpl::SocketImpl(
@@ -605,6 +607,7 @@ bool SSLServerContextImpl::SocketImpl::GetSSLInfo(SSLInfo* ssl_info) {
                                 &ssl_info->connection_status);
 
   ssl_info->early_data_received = early_data_received_;
+  ssl_info->encrypted_client_hello = SSL_ech_accepted(ssl_.get());
   ssl_info->handshake_type = SSL_session_reused(ssl_.get())
                                  ? SSLInfo::HANDSHAKE_RESUME
                                  : SSLInfo::HANDSHAKE_FULL;
@@ -1054,6 +1057,17 @@ void SSLServerContextImpl::Init() {
                               ssl_server_config_.ocsp_response.data(),
                               ssl_server_config_.ocsp_response.size());
   }
+
+  if (!ssl_server_config_.signed_cert_timestamp_list.empty()) {
+    SSL_CTX_set_signed_cert_timestamp_list(
+        ssl_ctx_.get(), ssl_server_config_.signed_cert_timestamp_list.data(),
+        ssl_server_config_.signed_cert_timestamp_list.size());
+  }
+
+  if (ssl_server_config_.ech_keys) {
+    CHECK(SSL_CTX_set1_ech_keys(ssl_ctx_.get(),
+                                ssl_server_config_.ech_keys.get()));
+  }
 }
 
 SSLServerContextImpl::~SSLServerContextImpl() = default;
diff --git a/chromium/net/socket/ssl_server_socket_unittest.cc b/chromium/net/socket/ssl_server_socket_unittest.cc
index f527d363e2d..1100a432780 100644
--- a/chromium/net/socket/ssl_server_socket_unittest.cc
+++ b/chromium/net/socket/ssl_server_socket_unittest.cc
@@ -109,6 +109,9 @@ class FakeDataChannel {
   FakeDataChannel()
       : read_buf_len_(0), closed_(false), write_called_after_close_(false) {}
 
+  FakeDataChannel(const FakeDataChannel&) = delete;
+  FakeDataChannel& operator=(const FakeDataChannel&) = delete;
+
   int Read(IOBuffer* buf, int buf_len, CompletionOnceCallback callback) {
     DCHECK(read_callback_.is_null());
     DCHECK(!read_buf_.get());
@@ -215,8 +218,6 @@ class FakeDataChannel {
   bool write_called_after_close_;
 
   base::WeakPtrFactory<FakeDataChannel> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(FakeDataChannel);
 };
 
 class FakeSocket : public StreamSocket {
@@ -225,6 +226,9 @@ class FakeSocket : public StreamSocket {
              FakeDataChannel* outgoing_channel)
       : incoming_(incoming_channel), outgoing_(outgoing_channel) {}
 
+  FakeSocket(const FakeSocket&) = delete;
+  FakeSocket& operator=(const FakeSocket&) = delete;
+
   ~FakeSocket() override = default;
 
   int Read(IOBuffer* buf,
@@ -299,8 +303,6 @@ class FakeSocket : public StreamSocket {
   NetLogWithSource net_log_;
   FakeDataChannel* incoming_;
   FakeDataChannel* outgoing_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeSocket);
 };
 
 }  // namespace
@@ -1138,7 +1140,7 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
 
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, run_loop.QuitClosure(), base::TimeDelta::FromMilliseconds(10));
+      FROM_HERE, run_loop.QuitClosure(), base::Milliseconds(10));
   run_loop.Run();
 }
 
diff --git a/chromium/net/socket/stream_socket.cc b/chromium/net/socket/stream_socket.cc
index f85ac8cc4c0..611369d50d2 100644
--- a/chromium/net/socket/stream_socket.cc
+++ b/chromium/net/socket/stream_socket.cc
@@ -23,11 +23,6 @@ void StreamSocket::GetSSLCertRequestInfo(
   NOTREACHED();
 }
 
-StreamSocket::SocketMemoryStats::SocketMemoryStats()
-    : total_size(0), buffer_size(0), cert_count(0), cert_size(0) {}
-
-StreamSocket::SocketMemoryStats::~SocketMemoryStats() = default;
-
 int StreamSocket::ConfirmHandshake(CompletionOnceCallback callback) {
   return OK;
 }
diff --git a/chromium/net/socket/stream_socket.h b/chromium/net/socket/stream_socket.h
index fd765764bd2..9ad18b90baa 100644
--- a/chromium/net/socket/stream_socket.h
+++ b/chromium/net/socket/stream_socket.h
@@ -29,25 +29,6 @@ class NET_EXPORT StreamSocket : public Socket {
  public:
   using BeforeConnectCallback = base::RepeatingCallback<int()>;
 
-  // This is used in DumpMemoryStats() to track the estimate of memory usage of
-  // a socket.
-  struct NET_EXPORT_PRIVATE SocketMemoryStats {
-   public:
-    SocketMemoryStats();
-    ~SocketMemoryStats();
-    // Estimated total memory usage of this socket in bytes.
-    size_t total_size;
-    // Size of all buffers used by this socket in bytes.
-    size_t buffer_size;
-    // Number of certs used by this socket.
-    size_t cert_count;
-    // Total size of certs used by this socket in bytes.
-    size_t cert_size;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(SocketMemoryStats);
-  };
-
   ~StreamSocket() override {}
 
   // Sets a callback to be invoked before establishing a connection. This allows
@@ -168,11 +149,6 @@ class NET_EXPORT StreamSocket : public Socket {
   // Disconnect() is called.
   virtual int64_t GetTotalReceivedBytes() const = 0;
 
-  // Dumps memory allocation stats into |stats|. |stats| can be assumed as being
-  // default initialized upon entry. Implementations should override fields in
-  // |stats|. Default implementation does nothing.
-  virtual void DumpMemoryStats(SocketMemoryStats* stats) const {}
-
   // Apply |tag| to this socket. If socket isn't yet connected, tag will be
   // applied when socket is later connected. If Connect() fails or socket
   // is closed, tag is cleared. If this socket is layered upon or wraps an
diff --git a/chromium/net/socket/tcp_client_socket.cc b/chromium/net/socket/tcp_client_socket.cc
index 6a28311f175..1436e075641 100644
--- a/chromium/net/socket/tcp_client_socket.cc
+++ b/chromium/net/socket/tcp_client_socket.cc
@@ -149,7 +149,7 @@ TCPClientSocket::TCPClientSocket(
     : socket_(std::move(socket)),
       bind_address_(std::move(bind_address)),
       addresses_(addresses),
-      current_address_index_(-1),
+      current_address_index_(current_address_index),
       next_connect_state_(CONNECT_STATE_NONE),
       previously_disconnected_(false),
       total_received_bytes_(0),
@@ -567,8 +567,7 @@ void TCPClientSocket::EmitTCPMetricsHistogramsOnDisconnect() {
   base::TimeDelta rtt;
   if (socket_->GetEstimatedRoundTripTime(&rtt)) {
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TcpRtt.AtDisconnect", rtt,
-                               base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMinutes(10), 100);
+                               base::Milliseconds(1), base::Minutes(10), 100);
   }
 }
 
diff --git a/chromium/net/socket/tcp_client_socket.h b/chromium/net/socket/tcp_client_socket.h
index c3888a9fbed..fbcb7e911e7 100644
--- a/chromium/net/socket/tcp_client_socket.h
+++ b/chromium/net/socket/tcp_client_socket.h
@@ -72,6 +72,9 @@ class NET_EXPORT TCPClientSocket : public TransportClientSocket,
       const IPEndPoint& bound_address,
       NetworkQualityEstimator* network_quality_estimator);
 
+  TCPClientSocket(const TCPClientSocket&) = delete;
+  TCPClientSocket& operator=(const TCPClientSocket&) = delete;
+
   ~TCPClientSocket() override;
 
   // TransportClientSocket implementation.
@@ -233,8 +236,6 @@ class NET_EXPORT TCPClientSocket : public TransportClientSocket,
   base::OneShotTimer connect_attempt_timer_;
 
   base::WeakPtrFactory<TCPClientSocket> weak_ptr_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(TCPClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/tcp_client_socket_unittest.cc b/chromium/net/socket/tcp_client_socket_unittest.cc
index 06a4e94a291..467544df104 100644
--- a/chromium/net/socket/tcp_client_socket_unittest.cc
+++ b/chromium/net/socket/tcp_client_socket_unittest.cc
@@ -295,6 +295,11 @@ TEST_F(TCPClientSocketTest, DnsAliasesPersistForReuse) {
 class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
  public:
   TestSocketPerformanceWatcher() : connection_changed_count_(0u) {}
+
+  TestSocketPerformanceWatcher(const TestSocketPerformanceWatcher&) = delete;
+  TestSocketPerformanceWatcher& operator=(const TestSocketPerformanceWatcher&) =
+      delete;
+
   ~TestSocketPerformanceWatcher() override = default;
 
   bool ShouldNotifyUpdatedRTT() const override { return true; }
@@ -307,8 +312,6 @@ class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
 
  private:
   size_t connection_changed_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher);
 };
 
 // TestSocketPerformanceWatcher requires kernel support for tcp_info struct, and
@@ -844,7 +847,7 @@ TEST_F(TCPClientSocketMockTimeTest, NoConnectAttemptTimeoutByDefault) {
   ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // After 4 minutes, the socket should still be connecting.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMinutes(4));
+  task_environment_.FastForwardBy(base::Minutes(4));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
@@ -855,8 +858,8 @@ TEST_F(TCPClientSocketMockTimeTest, NoConnectAttemptTimeoutByDefault) {
 // Tests that the maximum timeout is used when there is no estimated
 // RTT.
 TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMaxWhenNoRTT) {
-  OverrideTcpConnectAttemptTimeout override_timeout(
-      1, base::TimeDelta::FromSeconds(4), base::TimeDelta::FromSeconds(10));
+  OverrideTcpConnectAttemptTimeout override_timeout(1, base::Seconds(4),
+                                                    base::Seconds(10));
 
   IPEndPoint server_address(IPAddress::IPv4Localhost(), 80);
 
@@ -872,20 +875,20 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMaxWhenNoRTT) {
 
   // Advance to t=3.1s
   // Should still be pending, as this is before the minimum timeout.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(3100));
+  task_environment_.FastForwardBy(base::Milliseconds(3100));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
   // Advance to t=4.1s
   // Should still be pending. This is after the minimum timeout, but before the
   // maximum.
-  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(1));
+  task_environment_.FastForwardBy(base::Seconds(1));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
   // Advance to t=10.1s
   // Should now be timed out, as this is after the maximum timeout.
-  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(6));
+  task_environment_.FastForwardBy(base::Seconds(6));
   rv = connect_callback.GetResult(rv);
   ASSERT_THAT(rv, IsError(ERR_TIMED_OUT));
 
@@ -896,13 +899,12 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMaxWhenNoRTT) {
 // Tests that the minimum timeout is used when the adaptive timeout using RTT
 // ends up being too low.
 TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTLow) {
-  OverrideTcpConnectAttemptTimeout override_timeout(
-      5, base::TimeDelta::FromSeconds(4), base::TimeDelta::FromSeconds(10));
+  OverrideTcpConnectAttemptTimeout override_timeout(5, base::Seconds(4),
+                                                    base::Seconds(10));
 
   // Set the estimated RTT to 1 millisecond.
   TestNetworkQualityEstimator network_quality_estimator;
-  network_quality_estimator.SetStartTimeNullTransportRtt(
-      base::TimeDelta::FromMilliseconds(1));
+  network_quality_estimator.SetStartTimeNullTransportRtt(base::Milliseconds(1));
 
   IPEndPoint server_address(IPAddress::IPv4Localhost(), 80);
 
@@ -918,13 +920,13 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTLow) {
   // Advance to t=1.1s
   // Should be pending, since although the adaptive timeout has been reached, it
   // is lower than the minimum timeout.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(1100));
+  task_environment_.FastForwardBy(base::Milliseconds(1100));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
   // Advance to t=4.1s
   // Should have timed out due to hitting the minimum timeout.
-  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(3));
+  task_environment_.FastForwardBy(base::Seconds(3));
   rv = connect_callback.GetResult(rv);
   ASSERT_THAT(rv, IsError(ERR_TIMED_OUT));
 
@@ -935,13 +937,12 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTLow) {
 // Tests that the maximum timeout is used when the adaptive timeout from RTT is
 // too high.
 TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTHigh) {
-  OverrideTcpConnectAttemptTimeout override_timeout(
-      5, base::TimeDelta::FromSeconds(4), base::TimeDelta::FromSeconds(10));
+  OverrideTcpConnectAttemptTimeout override_timeout(5, base::Seconds(4),
+                                                    base::Seconds(10));
 
   // Set the estimated RTT to 5 seconds.
   TestNetworkQualityEstimator network_quality_estimator;
-  network_quality_estimator.SetStartTimeNullTransportRtt(
-      base::TimeDelta::FromSeconds(5));
+  network_quality_estimator.SetStartTimeNullTransportRtt(base::Seconds(5));
 
   IPEndPoint server_address(IPAddress::IPv4Localhost(), 80);
 
@@ -958,7 +959,7 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTHigh) {
   // The socket should have timed out due to hitting the maximum timeout. Had
   // the adaptive timeout been used, the socket would instead be timing out at
   // t=25s.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(10100));
+  task_environment_.FastForwardBy(base::Milliseconds(10100));
   rv = connect_callback.GetResult(rv);
   ASSERT_THAT(rv, IsError(ERR_TIMED_OUT));
 
@@ -969,14 +970,13 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesMinWhenRTTHigh) {
 // Tests that an adaptive timeout is used for TCP connection attempts based on
 // the estimated RTT.
 TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesRTT) {
-  OverrideTcpConnectAttemptTimeout override_timeout(
-      5, base::TimeDelta::FromSeconds(4), base::TimeDelta::FromSeconds(10));
+  OverrideTcpConnectAttemptTimeout override_timeout(5, base::Seconds(4),
+                                                    base::Seconds(10));
 
   // Set the estimated RTT to 1 second. Since the multiplier is set to 5, the
   // total adaptive timeout will be 5 seconds.
   TestNetworkQualityEstimator network_quality_estimator;
-  network_quality_estimator.SetStartTimeNullTransportRtt(
-      base::TimeDelta::FromSeconds(1));
+  network_quality_estimator.SetStartTimeNullTransportRtt(base::Seconds(1));
 
   IPEndPoint server_address(IPAddress::IPv4Localhost(), 80);
 
@@ -992,13 +992,13 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesRTT) {
   // Advance to t=4.1s
   // The socket should still be pending. Had the minimum timeout been enforced,
   // it would instead have timed out now.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(4100));
+  task_environment_.FastForwardBy(base::Milliseconds(4100));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
   // Advance to t=5.1s
   // The adaptive timeout was at t=5s, so it should now be timed out.
-  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(1));
+  task_environment_.FastForwardBy(base::Seconds(1));
   rv = connect_callback.GetResult(rv);
   ASSERT_THAT(rv, IsError(ERR_TIMED_OUT));
 
@@ -1009,8 +1009,8 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutUsesRTT) {
 // Tests that when multiple TCP connect attempts are made, the timeout for each
 // one is applied independently.
 TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutIndependent) {
-  OverrideTcpConnectAttemptTimeout override_timeout(
-      5, base::TimeDelta::FromSeconds(4), base::TimeDelta::FromSeconds(10));
+  OverrideTcpConnectAttemptTimeout override_timeout(5, base::Seconds(4),
+                                                    base::Seconds(10));
 
   // This test will attempt connecting to 5 endpoints.
   const size_t kNumIps = 5;
@@ -1029,14 +1029,14 @@ TEST_F(TCPClientSocketMockTimeTest, ConnectAttemptTimeoutIndependent) {
 
   // Advance to t=49s
   // Should still be pending.
-  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(49));
+  task_environment_.FastForwardBy(base::Seconds(49));
   EXPECT_FALSE(connect_callback.have_result());
   EXPECT_FALSE(socket.IsConnected());
 
   // Advance to t=50.1s
   // All attempts should take 50 seconds to complete (5 attempts, 10 seconds
   // each). So by this point the overall connect attempt will have timed out.
-  task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(1100));
+  task_environment_.FastForwardBy(base::Milliseconds(1100));
   rv = connect_callback.GetResult(rv);
   ASSERT_THAT(rv, IsError(ERR_TIMED_OUT));
 
diff --git a/chromium/net/socket/tcp_server_socket.h b/chromium/net/socket/tcp_server_socket.h
index 8e5c9e5f3b5..9c2b856219c 100644
--- a/chromium/net/socket/tcp_server_socket.h
+++ b/chromium/net/socket/tcp_server_socket.h
@@ -28,6 +28,9 @@ class NET_EXPORT TCPServerSocket : public ServerSocket {
   // Adopts the provided socket, which must not be a connected socket.
   explicit TCPServerSocket(std::unique_ptr<TCPSocket> socket);
 
+  TCPServerSocket(const TCPServerSocket&) = delete;
+  TCPServerSocket& operator=(const TCPServerSocket&) = delete;
+
   ~TCPServerSocket() override;
 
   // Takes ownership of |socket|, which has been opened, but may or may not be
@@ -70,8 +73,6 @@ class NET_EXPORT TCPServerSocket : public ServerSocket {
   std::unique_ptr<TCPSocket> accepted_socket_;
   IPEndPoint accepted_address_;
   bool pending_accept_;
-
-  DISALLOW_COPY_AND_ASSIGN(TCPServerSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/tcp_socket_posix.cc b/chromium/net/socket/tcp_socket_posix.cc
index efe4d563b92..bd6f087e957 100644
--- a/chromium/net/socket/tcp_socket_posix.cc
+++ b/chromium/net/socket/tcp_socket_posix.cc
@@ -124,8 +124,7 @@ base::TimeDelta GetTransportRtt(SocketDescriptor fd) {
     return base::TimeDelta();
   }
 
-  return base::TimeDelta::FromMicroseconds(
-      std::max(info.tcpi_rtt, kMinValidRttMicros));
+  return base::Microseconds(std::max(info.tcpi_rtt, kMinValidRttMicros));
 }
 
 #endif  // defined(TCP_INFO)
diff --git a/chromium/net/socket/tcp_socket_posix.h b/chromium/net/socket/tcp_socket_posix.h
index 31430b6120f..32cf7242d48 100644
--- a/chromium/net/socket/tcp_socket_posix.h
+++ b/chromium/net/socket/tcp_socket_posix.h
@@ -43,6 +43,10 @@ class NET_EXPORT TCPSocketPosix {
       std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
       NetLog* net_log,
       const NetLogSource& source);
+
+  TCPSocketPosix(const TCPSocketPosix&) = delete;
+  TCPSocketPosix& operator=(const TCPSocketPosix&) = delete;
+
   virtual ~TCPSocketPosix();
 
   // Opens the socket.
@@ -211,8 +215,6 @@ class NET_EXPORT TCPSocketPosix {
   // Current socket tag if |socket_| is valid, otherwise the tag to apply when
   // |socket_| is opened.
   SocketTag tag_;
-
-  DISALLOW_COPY_AND_ASSIGN(TCPSocketPosix);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/tcp_socket_unittest.cc b/chromium/net/socket/tcp_socket_unittest.cc
index 74b60b784c9..74f8e1d8011 100644
--- a/chromium/net/socket/tcp_socket_unittest.cc
+++ b/chromium/net/socket/tcp_socket_unittest.cc
@@ -73,6 +73,11 @@ class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
       : should_notify_updated_rtt_(should_notify_updated_rtt),
         connection_changed_count_(0u),
         rtt_notification_count_(0u) {}
+
+  TestSocketPerformanceWatcher(const TestSocketPerformanceWatcher&) = delete;
+  TestSocketPerformanceWatcher& operator=(const TestSocketPerformanceWatcher&) =
+      delete;
+
   ~TestSocketPerformanceWatcher() override = default;
 
   bool ShouldNotifyUpdatedRTT() const override {
@@ -93,8 +98,6 @@ class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
   const bool should_notify_updated_rtt_;
   size_t connection_changed_count_;
   size_t rtt_notification_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher);
 };
 
 const int kListenBacklog = 5;
@@ -523,9 +526,9 @@ TEST_F(TCPSocketTest, DestroyWithPendingWrite) {
   memset(write_buffer->data(), '1', write_buffer->size());
   TestCompletionCallback write_callback;
   while (true) {
-    int result = connecting_socket->Write(
-        write_buffer.get(), write_buffer->size(), write_callback.callback(),
-        TRAFFIC_ANNOTATION_FOR_TESTS);
+    result = connecting_socket->Write(write_buffer.get(), write_buffer->size(),
+                                      write_callback.callback(),
+                                      TRAFFIC_ANNOTATION_FOR_TESTS);
     if (result == ERR_IO_PENDING)
       break;
     ASSERT_LT(0, result);
diff --git a/chromium/net/socket/tcp_socket_win.cc b/chromium/net/socket/tcp_socket_win.cc
index 2cd61ffc500..6582dc32b9f 100644
--- a/chromium/net/socket/tcp_socket_win.cc
+++ b/chromium/net/socket/tcp_socket_win.cc
@@ -13,6 +13,7 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/check_op.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ -107,6 +108,9 @@ class TCPSocketWin::Core : public base::RefCounted<Core> {
  public:
   explicit Core(TCPSocketWin* socket);
 
+  Core(const Core&) = delete;
+  Core& operator=(const Core&) = delete;
+
   // Start watching for the end of a read or write operation.
   void WatchForRead();
   void WatchForWrite();
@@ -175,8 +179,6 @@ class TCPSocketWin::Core : public base::RefCounted<Core> {
   base::win::ObjectWatcher read_watcher_;
   // |write_watcher_| watches for events from Write();
   base::win::ObjectWatcher write_watcher_;
-
-  DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 TCPSocketWin::Core::Core(TCPSocketWin* socket)
@@ -563,8 +565,6 @@ int TCPSocketWin::Write(
   write_buffer.len = buf_len;
   write_buffer.buf = buf->data();
 
-  // TODO(wtc): Remove the assertion after enough testing.
-  AssertEventNotSignaled(core_->write_overlapped_.hEvent);
   DWORD num;
   int rv = WSASend(socket_, &write_buffer, 1, &num, 0,
                    &core_->write_overlapped_, nullptr);
@@ -850,15 +850,6 @@ int TCPSocketWin::DoConnect() {
   if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
-  // Set option to choose a random port, if the socket is not already bound.
-  // Ignore failures, which may happen if the socket was already bound.
-  // Microsoft's documentation claims this is a uint16, but experimentally, this
-  // fails if passed a 16-bit value.
-  std::uint32_t randomize_port_value = 1;
-  setsockopt(socket_, SOL_SOCKET, SO_RANDOMIZE_PORT,
-             reinterpret_cast<const char*>(&randomize_port_value),
-             sizeof(randomize_port_value));
-
   if (!connect(socket_, storage.addr, storage.addr_len)) {
     // Connected without waiting!
     //
diff --git a/chromium/net/socket/tcp_socket_win.h b/chromium/net/socket/tcp_socket_win.h
index 8decd5d5d4a..542bf8dd2c6 100644
--- a/chromium/net/socket/tcp_socket_win.h
+++ b/chromium/net/socket/tcp_socket_win.h
@@ -38,6 +38,10 @@ class NET_EXPORT TCPSocketWin : public base::win::ObjectWatcher::Delegate {
       std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
       NetLog* net_log,
       const NetLogSource& source);
+
+  TCPSocketWin(const TCPSocketWin&) = delete;
+  TCPSocketWin& operator=(const TCPSocketWin&) = delete;
+
   ~TCPSocketWin() override;
 
   int Open(AddressFamily family);
@@ -199,8 +203,6 @@ class NET_EXPORT TCPSocketWin : public base::win::ObjectWatcher::Delegate {
   NetLogWithSource net_log_;
 
   THREAD_CHECKER(thread_checker_);
-
-  DISALLOW_COPY_AND_ASSIGN(TCPSocketWin);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/transport_client_socket.h b/chromium/net/socket/transport_client_socket.h
index 4f8c4b3fde1..548048e92bf 100644
--- a/chromium/net/socket/transport_client_socket.h
+++ b/chromium/net/socket/transport_client_socket.h
@@ -17,6 +17,10 @@ namespace net {
 class NET_EXPORT TransportClientSocket : public StreamSocket {
  public:
   TransportClientSocket();
+
+  TransportClientSocket(const TransportClientSocket&) = delete;
+  TransportClientSocket& operator=(const TransportClientSocket&) = delete;
+
   ~TransportClientSocket() override;
 
   // Binds the socket to a local address, |local_addr|. Returns OK on success,
@@ -46,9 +50,6 @@ class NET_EXPORT TransportClientSocket : public StreamSocket {
   // should always be ready after successful connection or slightly earlier
   // during BeforeConnect handlers.
   virtual bool SetKeepAlive(bool enable, int delay_secs);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TransportClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/transport_client_socket_pool.cc b/chromium/net/socket/transport_client_socket_pool.cc
index 6b53f8fbfbd..38909efca9f 100644
--- a/chromium/net/socket/transport_client_socket_pool.cc
+++ b/chromium/net/socket/transport_client_socket_pool.cc
@@ -21,8 +21,6 @@
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/process_memory_dump.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
@@ -34,7 +32,6 @@
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "url/gurl.h"
 
-using base::TimeDelta;
 
 namespace net {
 
@@ -723,48 +720,6 @@ base::Value TransportClientSocketPool::GetInfoAsValue(
   return dict;
 }
 
-void TransportClientSocketPool::DumpMemoryStats(
-    base::trace_event::ProcessMemoryDump* pmd,
-    const std::string& parent_dump_absolute_name) const {
-  size_t socket_count = 0;
-  size_t total_size = 0;
-  size_t buffer_size = 0;
-  size_t cert_count = 0;
-  size_t cert_size = 0;
-  for (const auto& kv : group_map_) {
-    for (const auto& socket : kv.second->idle_sockets()) {
-      StreamSocket::SocketMemoryStats stats;
-      socket.socket->DumpMemoryStats(&stats);
-      total_size += stats.total_size;
-      buffer_size += stats.buffer_size;
-      cert_count += stats.cert_count;
-      cert_size += stats.cert_size;
-      ++socket_count;
-    }
-  }
-  // Only create a MemoryAllocatorDump if there is at least one idle socket
-  if (socket_count > 0) {
-    base::trace_event::MemoryAllocatorDump* socket_pool_dump =
-        pmd->CreateAllocatorDump(base::StringPrintf(
-            "%s/socket_pool", parent_dump_absolute_name.c_str()));
-    socket_pool_dump->AddScalar(
-        base::trace_event::MemoryAllocatorDump::kNameSize,
-        base::trace_event::MemoryAllocatorDump::kUnitsBytes, total_size);
-    socket_pool_dump->AddScalar(
-        base::trace_event::MemoryAllocatorDump::kNameObjectCount,
-        base::trace_event::MemoryAllocatorDump::kUnitsObjects, socket_count);
-    socket_pool_dump->AddScalar(
-        "buffer_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-        buffer_size);
-    socket_pool_dump->AddScalar(
-        "cert_count", base::trace_event::MemoryAllocatorDump::kUnitsObjects,
-        cert_count);
-    socket_pool_dump->AddScalar(
-        "cert_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-        cert_size);
-  }
-}
-
 bool TransportClientSocketPool::IdleSocket::IsUsable(
     const char** net_log_reason_utf8) const {
   DCHECK(net_log_reason_utf8);
diff --git a/chromium/net/socket/transport_client_socket_pool.h b/chromium/net/socket/transport_client_socket_pool.h
index 80f432de5ff..fad163d0bf3 100644
--- a/chromium/net/socket/transport_client_socket_pool.h
+++ b/chromium/net/socket/transport_client_socket_pool.h
@@ -41,12 +41,6 @@
 #include "net/socket/stream_socket.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 
-namespace base {
-namespace trace_event {
-class ProcessMemoryDump;
-}
-}  // namespace base
-
 namespace net {
 
 struct CommonConnectJobParams;
@@ -107,6 +101,9 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
         const absl::optional<NetworkTrafficAnnotationTag>& proxy_annotation_tag,
         const NetLogWithSource& net_log);
 
+    Request(const Request&) = delete;
+    Request& operator=(const Request&) = delete;
+
     ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
@@ -147,8 +144,6 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
     const NetLogWithSource net_log_;
     const SocketTag socket_tag_;
     ConnectJob* job_;
-
-    DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   TransportClientSocketPool(
@@ -159,6 +154,10 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
       bool is_for_websockets,
       const CommonConnectJobParams* common_connect_job_params);
 
+  TransportClientSocketPool(const TransportClientSocketPool&) = delete;
+  TransportClientSocketPool& operator=(const TransportClientSocketPool&) =
+      delete;
+
   // Creates a socket pool with an alternative ConnectJobFactory, for use in
   // testing.
   //
@@ -223,9 +222,6 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
                          const ClientSocketHandle* handle) const override;
   base::Value GetInfoAsValue(const std::string& name,
                              const std::string& type) const override;
-  void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const override;
 
   bool RequestInGroupWithHandleHasJobForTesting(
       const GroupId& group_id,
@@ -607,7 +603,7 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
   base::TimeDelta ConnectRetryInterval() const {
     // TODO(mbelshe): Make this tuned dynamically based on measured RTT.
     //                For now, just use the max retry interval.
-    return base::TimeDelta::FromMilliseconds(kMaxConnectRetryIntervalMs);
+    return base::Milliseconds(kMaxConnectRetryIntervalMs);
   }
 
   // TODO(mmenke): de-inline these.
@@ -801,8 +797,6 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool
   SSLClientContext* const ssl_client_context_;
 
   base::WeakPtrFactory<TransportClientSocketPool> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/transport_client_socket_pool_test_util.cc b/chromium/net/socket/transport_client_socket_pool_test_util.cc
index 73c44927732..2f25c2deb35 100644
--- a/chromium/net/socket/transport_client_socket_pool_test_util.cc
+++ b/chromium/net/socket/transport_client_socket_pool_test_util.cc
@@ -49,6 +49,9 @@ class MockConnectClientSocket : public TransportClientSocket {
         addrlist_(addrlist),
         net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
 
+  MockConnectClientSocket(const MockConnectClientSocket&) = delete;
+  MockConnectClientSocket& operator=(const MockConnectClientSocket&) = delete;
+
   // TransportClientSocket implementation.
   int Bind(const net::IPEndPoint& local_addr) override {
     NOTREACHED();
@@ -112,8 +115,6 @@ class MockConnectClientSocket : public TransportClientSocket {
   bool connected_;
   const AddressList addrlist_;
   NetLogWithSource net_log_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockConnectClientSocket);
 };
 
 class MockFailingClientSocket : public TransportClientSocket {
@@ -122,6 +123,9 @@ class MockFailingClientSocket : public TransportClientSocket {
       : addrlist_(addrlist),
         net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
 
+  MockFailingClientSocket(const MockFailingClientSocket&) = delete;
+  MockFailingClientSocket& operator=(const MockFailingClientSocket&) = delete;
+
   // TransportClientSocket implementation.
   int Bind(const net::IPEndPoint& local_addr) override {
     NOTREACHED();
@@ -181,8 +185,6 @@ class MockFailingClientSocket : public TransportClientSocket {
  private:
   const AddressList addrlist_;
   NetLogWithSource net_log_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket);
 };
 
 class MockTriggerableClientSocket : public TransportClientSocket {
@@ -197,6 +199,10 @@ class MockTriggerableClientSocket : public TransportClientSocket {
         addrlist_(addrlist),
         net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
 
+  MockTriggerableClientSocket(const MockTriggerableClientSocket&) = delete;
+  MockTriggerableClientSocket& operator=(const MockTriggerableClientSocket&) =
+      delete;
+
   // Call this method to get a closure which will trigger the connect callback
   // when called. The closure can be called even after the socket is deleted; it
   // will safely do nothing.
@@ -323,8 +329,6 @@ class MockTriggerableClientSocket : public TransportClientSocket {
   ConnectionAttempts connection_attempts_;
 
   base::WeakPtrFactory<MockTriggerableClientSocket> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(MockTriggerableClientSocket);
 };
 
 }  // namespace
@@ -374,8 +378,8 @@ MockTransportClientSocketFactory::MockTransportClientSocketFactory(
       client_socket_types_(nullptr),
       client_socket_index_(0),
       client_socket_index_max_(0),
-      delay_(base::TimeDelta::FromMilliseconds(
-          ClientSocketPool::kMaxConnectRetryIntervalMs)) {}
+      delay_(base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs)) {
+}
 
 MockTransportClientSocketFactory::~MockTransportClientSocketFactory() = default;
 
diff --git a/chromium/net/socket/transport_client_socket_pool_test_util.h b/chromium/net/socket/transport_client_socket_pool_test_util.h
index f6dfb7b774f..91b69d3e1ef 100644
--- a/chromium/net/socket/transport_client_socket_pool_test_util.h
+++ b/chromium/net/socket/transport_client_socket_pool_test_util.h
@@ -72,6 +72,12 @@ class MockTransportClientSocketFactory : public ClientSocketFactory {
   };
 
   explicit MockTransportClientSocketFactory(NetLog* net_log);
+
+  MockTransportClientSocketFactory(const MockTransportClientSocketFactory&) =
+      delete;
+  MockTransportClientSocketFactory& operator=(
+      const MockTransportClientSocketFactory&) = delete;
+
   ~MockTransportClientSocketFactory() override;
 
   std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
@@ -135,8 +141,6 @@ class MockTransportClientSocketFactory : public ClientSocketFactory {
   base::TimeDelta delay_;
   base::queue<base::OnceClosure> triggerable_sockets_;
   base::OnceClosure run_loop_quit_closure_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketFactory);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/transport_client_socket_pool_unittest.cc b/chromium/net/socket/transport_client_socket_pool_unittest.cc
index 62ab35e5a5d..7782fd287bf 100644
--- a/chromium/net/socket/transport_client_socket_pool_unittest.cc
+++ b/chromium/net/socket/transport_client_socket_pool_unittest.cc
@@ -25,6 +25,7 @@
 #include "net/base/net_errors.h"
 #include "net/base/privacy_mode.h"
 #include "net/base/proxy_server.h"
+#include "net/base/proxy_string_util.h"
 #include "net/base/schemeful_site.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/ct_policy_enforcer.h"
@@ -69,8 +70,7 @@ namespace {
 
 const int kMaxSockets = 32;
 const int kMaxSocketsPerGroup = 6;
-constexpr base::TimeDelta kUnusedIdleSocketTimeout =
-    base::TimeDelta::FromSeconds(10);
+constexpr base::TimeDelta kUnusedIdleSocketTimeout = base::Seconds(10);
 const RequestPriority kDefaultPriority = LOW;
 
 class SOCKS5MockData {
@@ -100,6 +100,11 @@ class SOCKS5MockData {
 
 class TransportClientSocketPoolTest : public ::testing::Test,
                                       public WithTaskEnvironment {
+ public:
+  TransportClientSocketPoolTest(const TransportClientSocketPoolTest&) = delete;
+  TransportClientSocketPoolTest& operator=(
+      const TransportClientSocketPoolTest&) = delete;
+
  protected:
   // Constructor that allows mocking of the time.
   explicit TransportClientSocketPoolTest(
@@ -217,9 +222,6 @@ class TransportClientSocketPoolTest : public ::testing::Test,
   std::unique_ptr<TransportClientSocketPool> pool_for_real_sockets_;
 
   ClientSocketPoolTest test_base_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPoolTest);
 };
 
 TEST_F(TransportClientSocketPoolTest, Basic) {
@@ -864,6 +866,9 @@ class RequestSocketCallback : public TestCompletionCallbackBase {
         pool_(pool),
         within_callback_(false) {}
 
+  RequestSocketCallback(const RequestSocketCallback&) = delete;
+  RequestSocketCallback& operator=(const RequestSocketCallback&) = delete;
+
   ~RequestSocketCallback() override = default;
 
   CompletionOnceCallback callback() {
@@ -897,8 +902,6 @@ class RequestSocketCallback : public TestCompletionCallbackBase {
   ClientSocketHandle* const handle_;
   TransportClientSocketPool* const pool_;
   bool within_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback);
 };
 
 TEST_F(TransportClientSocketPoolTest, RequestTwice) {
@@ -1139,8 +1142,8 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {
     base::RunLoop().RunUntilIdle();
 
     // Wait for the backup socket timer to fire.
-    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
-        ClientSocketPool::kMaxConnectRetryIntervalMs + 50));
+    base::PlatformThread::Sleep(
+        base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs + 50));
 
     // Let the appropriate socket connect.
     base::RunLoop().RunUntilIdle();
@@ -1185,8 +1188,8 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {
 
     if (index == CANCEL_AFTER_WAIT) {
       // Wait for the backup socket timer to fire.
-      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
-          ClientSocketPool::kMaxConnectRetryIntervalMs));
+      base::PlatformThread::Sleep(
+          base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
     }
 
     // Let the appropriate socket connect.
@@ -1233,8 +1236,8 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {
   base::RunLoop().RunUntilIdle();
 
   // Wait for the backup socket timer to fire.
-  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs));
+  base::PlatformThread::Sleep(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
 
   // Let the second connect be synchronous. Otherwise, the emulated
   // host resolution takes an extra trip through the message loop.
@@ -1265,7 +1268,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {
   };
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
-  client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(5));
+  client_socket_factory_.set_delay(base::Seconds(5));
 
   EXPECT_EQ(0, pool_->IdleSocketCount());
 
@@ -1284,8 +1287,8 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {
   base::RunLoop().RunUntilIdle();
 
   // Wait for the backup socket timer to fire.
-  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
-      ClientSocketPool::kMaxConnectRetryIntervalMs));
+  base::PlatformThread::Sleep(
+      base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
 
   // Let the second connect be synchronous. Otherwise, the emulated
   // host resolution takes an extra trip through the message loop.
@@ -1309,8 +1312,8 @@ TEST_F(TransportClientSocketPoolTest, SOCKS) {
 
   TransportClientSocketPool proxy_pool(
       kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("socks5://foopy",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("socks5://foopy",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   for (IoMode socket_io_mode : {SYNCHRONOUS, ASYNC}) {
@@ -1353,8 +1356,8 @@ TEST_F(TransportClientSocketPoolTest, SpdyOneConnectJobTwoRequestsError) {
   // Create a socket pool which only allows a single connection at a time.
   TransportClientSocketPool pool(
       1, 1, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("https://unresolvable.proxy.name",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("https://unresolvable.proxy.name",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   // First connection attempt will get an error after creating the SpdyStream.
@@ -1445,8 +1448,8 @@ TEST_F(TransportClientSocketPoolTest, SpdyAuthOneConnectJobTwoRequests) {
   // Create a socket pool which only allows a single connection at a time.
   TransportClientSocketPool pool(
       1, 1, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("https://unresolvable.proxy.name",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("https://unresolvable.proxy.name",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   SpdyTestUtil spdy_util;
@@ -1565,7 +1568,7 @@ TEST_F(TransportClientSocketPoolTest, HttpTunnelSetupRedirect) {
 
       TransportClientSocketPool proxy_pool(
           kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
-          ProxyServer::FromURI(
+          ProxyUriToProxyServer(
               use_https_proxy ? "https://proxy.test" : "http://proxy.test",
               ProxyServer::SCHEME_HTTP /* default_scheme */),
           false /* is_for_websockets */,
@@ -1696,7 +1699,7 @@ TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpProxy) {
   const SchemefulSite kSite2(GURL("https://bar.test/"));
   const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
   const char kHost[] = "bar.test";
-  const ProxyServer kProxyServer = ProxyServer::FromURI(
+  const ProxyServer kProxyServer = ProxyUriToProxyServer(
       "http://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
 
   base::test::ScopedFeatureList scoped_feature_list;
@@ -1767,7 +1770,7 @@ TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpsProxy) {
   const SchemefulSite kSite2(GURL("https://bar.test/"));
   const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
   const char kHost[] = "bar.test";
-  const ProxyServer kProxyServer = ProxyServer::FromURI(
+  const ProxyServer kProxyServer = ProxyUriToProxyServer(
       "https://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
 
   base::test::ScopedFeatureList scoped_feature_list;
@@ -1839,7 +1842,7 @@ TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks4Proxy) {
   const SchemefulSite kSite2(GURL("https://bar.test/"));
   const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
   const char kHost[] = "bar.test";
-  const ProxyServer kProxyServer = ProxyServer::FromURI(
+  const ProxyServer kProxyServer = ProxyUriToProxyServer(
       "socks4://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
 
   base::test::ScopedFeatureList scoped_feature_list;
@@ -1933,7 +1936,7 @@ TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks5Proxy) {
   const SchemefulSite kSite2(GURL("https://bar.test/"));
   const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
   const char kHost[] = "bar.test";
-  const ProxyServer kProxyServer = ProxyServer::FromURI(
+  const ProxyServer kProxyServer = ProxyUriToProxyServer(
       "socks5://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
 
   base::test::ScopedFeatureList scoped_feature_list;
@@ -2137,8 +2140,8 @@ TEST_F(TransportClientSocketPoolTest, TagSOCKSProxy) {
 
   TransportClientSocketPool proxy_pool(
       kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("socks5://proxy",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("socks5://proxy",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
@@ -2442,8 +2445,8 @@ TEST_F(TransportClientSocketPoolTest, TagHttpProxyNoTunnel) {
 
   TransportClientSocketPool proxy_pool(
       kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("http://proxy",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("http://proxy",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   session_deps_.host_resolver->set_synchronous_mode(true);
@@ -2502,8 +2505,8 @@ TEST_F(TransportClientSocketPoolTest, TagHttpProxyTunnel) {
 
   TransportClientSocketPool proxy_pool(
       kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
-      ProxyServer::FromURI("http://proxy",
-                           ProxyServer::SCHEME_HTTP /* default_scheme */),
+      ProxyUriToProxyServer("http://proxy",
+                            ProxyServer::SCHEME_HTTP /* default_scheme */),
       false /* is_for_websockets */, tagging_common_connect_job_params_.get());
 
   session_deps_.host_resolver->set_synchronous_mode(true);
@@ -2572,13 +2575,16 @@ TEST_F(TransportClientSocketPoolTest, TagHttpProxyTunnel) {
 // Class that enables tests to set mock time.
 class TransportClientSocketPoolMockNowSourceTest
     : public TransportClientSocketPoolTest {
+ public:
+  TransportClientSocketPoolMockNowSourceTest(
+      const TransportClientSocketPoolMockNowSourceTest&) = delete;
+  TransportClientSocketPoolMockNowSourceTest& operator=(
+      const TransportClientSocketPoolMockNowSourceTest&) = delete;
+
  protected:
   TransportClientSocketPoolMockNowSourceTest()
       : TransportClientSocketPoolTest(
             base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPoolMockNowSourceTest);
 };
 
 // Tests that changing the idle unused socket timeout using the experiment
@@ -2666,7 +2672,7 @@ TEST_F(TransportClientSocketPoolMockNowSourceTest, IdleUnusedSocketTimeout) {
         // character to the latter.
         auto write_buffer = base::MakeRefCounted<StringIOBuffer>(kWriteData);
         TestCompletionCallback write_callback;
-        int rv = connection.socket()->Write(
+        rv = connection.socket()->Write(
             write_buffer.get(), write_buffer->size(), write_callback.callback(),
             TRAFFIC_ANNOTATION_FOR_TESTS);
         EXPECT_EQ(rv, 1);
@@ -2680,7 +2686,7 @@ TEST_F(TransportClientSocketPoolMockNowSourceTest, IdleUnusedSocketTimeout) {
                      ->IdleSocketCount());
 
     // Moving the clock forward may cause the idle socket to be timedout.
-    FastForwardBy(base::TimeDelta::FromSeconds(test.fast_forward_seconds));
+    FastForwardBy(base::Seconds(test.fast_forward_seconds));
 
     {
       // Request a new socket to trigger cleanup of idle timedout sockets.
diff --git a/chromium/net/socket/transport_connect_job.cc b/chromium/net/socket/transport_connect_job.cc
index 7c5c9ddbdf2..36bf77d4dce 100644
--- a/chromium/net/socket/transport_connect_job.cc
+++ b/chromium/net/socket/transport_connect_job.cc
@@ -205,42 +205,36 @@ void TransportConnectJob::HistogramDuration(
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta total_duration = now - connect_timing.dns_start;
   UMA_HISTOGRAM_CUSTOM_TIMES("Net.DNS_Resolution_And_TCP_Connection_Latency2",
-                             total_duration,
-                             base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMinutes(10), 100);
+                             total_duration, base::Milliseconds(1),
+                             base::Minutes(10), 100);
 
   base::TimeDelta connect_duration = now - connect_timing.connect_start;
   UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency", connect_duration,
-                             base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMinutes(10), 100);
+                             base::Milliseconds(1), base::Minutes(10), 100);
 
   switch (race_result) {
     case RACE_IPV4_WINS:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_Wins_Race",
-                                 connect_duration,
-                                 base::TimeDelta::FromMilliseconds(1),
-                                 base::TimeDelta::FromMinutes(10), 100);
+                                 connect_duration, base::Milliseconds(1),
+                                 base::Minutes(10), 100);
       break;
 
     case RACE_IPV4_SOLO:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_No_Race",
-                                 connect_duration,
-                                 base::TimeDelta::FromMilliseconds(1),
-                                 base::TimeDelta::FromMinutes(10), 100);
+                                 connect_duration, base::Milliseconds(1),
+                                 base::Minutes(10), 100);
       break;
 
     case RACE_IPV6_WINS:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Raceable",
-                                 connect_duration,
-                                 base::TimeDelta::FromMilliseconds(1),
-                                 base::TimeDelta::FromMinutes(10), 100);
+                                 connect_duration, base::Milliseconds(1),
+                                 base::Minutes(10), 100);
       break;
 
     case RACE_IPV6_SOLO:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Solo",
-                                 connect_duration,
-                                 base::TimeDelta::FromMilliseconds(1),
-                                 base::TimeDelta::FromMinutes(10), 100);
+                                 connect_duration, base::Milliseconds(1),
+                                 base::Minutes(10), 100);
       break;
 
     default:
@@ -251,7 +245,7 @@ void TransportConnectJob::HistogramDuration(
 
 // static
 base::TimeDelta TransportConnectJob::ConnectionTimeout() {
-  return base::TimeDelta::FromSeconds(TransportConnectJob::kTimeoutInSeconds);
+  return base::Seconds(TransportConnectJob::kTimeoutInSeconds);
 }
 
 void TransportConnectJob::OnIOComplete(int result) {
@@ -299,9 +293,15 @@ int TransportConnectJob::DoResolveHost() {
   HostResolver::ResolveHostParameters parameters;
   parameters.initial_priority = priority();
   parameters.secure_dns_policy = params_->secure_dns_policy();
-  request_ = host_resolver()->CreateRequest(
-      ToLegacyDestinationEndpoint(params_->destination()),
-      params_->network_isolation_key(), net_log(), parameters);
+  if (absl::holds_alternative<url::SchemeHostPort>(params_->destination())) {
+    request_ = host_resolver()->CreateRequest(
+        absl::get<url::SchemeHostPort>(params_->destination()),
+        params_->network_isolation_key(), net_log(), parameters);
+  } else {
+    request_ = host_resolver()->CreateRequest(
+        absl::get<HostPortPair>(params_->destination()),
+        params_->network_isolation_key(), net_log(), parameters);
+  }
 
   return request_->Start(base::BindOnce(&TransportConnectJob::OnIOComplete,
                                         base::Unretained(this)));
@@ -369,9 +369,9 @@ int TransportConnectJob::DoTransportConnect() {
   int rv = transport_socket_->Connect(base::BindOnce(
       &TransportConnectJob::OnIOComplete, base::Unretained(this)));
   if (rv == ERR_IO_PENDING && try_ipv6_connect_with_ipv4_fallback) {
-    fallback_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromMilliseconds(kIPv6FallbackTimerInMs),
-        this, &TransportConnectJob::DoIPv6FallbackTransportConnect);
+    fallback_timer_.Start(FROM_HERE, base::Milliseconds(kIPv6FallbackTimerInMs),
+                          this,
+                          &TransportConnectJob::DoIPv6FallbackTransportConnect);
   }
   return rv;
 }
diff --git a/chromium/net/socket/transport_connect_job.h b/chromium/net/socket/transport_connect_job.h
index acf2c6be073..b1030946c16 100644
--- a/chromium/net/socket/transport_connect_job.h
+++ b/chromium/net/socket/transport_connect_job.h
@@ -48,6 +48,9 @@ class NET_EXPORT_PRIVATE TransportSocketParams
                         SecureDnsPolicy secure_dns_policy,
                         OnHostResolutionCallback host_resolution_callback);
 
+  TransportSocketParams(const TransportSocketParams&) = delete;
+  TransportSocketParams& operator=(const TransportSocketParams&) = delete;
+
   const Endpoint& destination() const { return destination_; }
   const NetworkIsolationKey& network_isolation_key() const {
     return network_isolation_key_;
@@ -65,8 +68,6 @@ class NET_EXPORT_PRIVATE TransportSocketParams
   const NetworkIsolationKey network_isolation_key_;
   const SecureDnsPolicy secure_dns_policy_;
   const OnHostResolutionCallback host_resolution_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
 };
 
 // TransportConnectJob handles the host resolution necessary for socket creation
@@ -129,6 +130,10 @@ class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
                       const scoped_refptr<TransportSocketParams>& params,
                       Delegate* delegate,
                       const NetLogWithSource* net_log);
+
+  TransportConnectJob(const TransportConnectJob&) = delete;
+  TransportConnectJob& operator=(const TransportConnectJob&) = delete;
+
   ~TransportConnectJob() override;
 
   // ConnectJob methods.
@@ -205,8 +210,6 @@ class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
   ConnectionAttempts fallback_connection_attempts_;
 
   base::WeakPtrFactory<TransportConnectJob> weak_ptr_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(TransportConnectJob);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/transport_connect_job_unittest.cc b/chromium/net/socket/transport_connect_job_unittest.cc
index 66df9f37488..67a7165aa23 100644
--- a/chromium/net/socket/transport_connect_job_unittest.cc
+++ b/chromium/net/socket/transport_connect_job_unittest.cc
@@ -182,7 +182,7 @@ TEST_F(TransportConnectJobTest, ConnectionFailure) {
 }
 
 TEST_F(TransportConnectJobTest, HostResolutionTimeout) {
-  const base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+  const base::TimeDelta kTinyTime = base::Microseconds(1);
 
   // Make request hang.
   host_resolver_.set_ondemand_mode(true);
@@ -204,7 +204,7 @@ TEST_F(TransportConnectJobTest, HostResolutionTimeout) {
 }
 
 TEST_F(TransportConnectJobTest, ConnectionTimeout) {
-  const base::TimeDelta kTinyTime = base::TimeDelta::FromMicroseconds(1);
+  const base::TimeDelta kTinyTime = base::Microseconds(1);
 
   // Half the timeout time. In the async case, spend half the time waiting on
   // host resolution, half on connecting.
@@ -361,8 +361,8 @@ TEST_F(TransportConnectJobTest, IPv6FallbackSocketIPv6FinishesFirst) {
       MockTransportClientSocketFactory::MOCK_STALLED_FAILING_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
-  client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds(
-      TransportConnectJob::kIPv6FallbackTimerInMs + 50));
+  client_socket_factory_.set_delay(
+      base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs + 50));
 
   // Resolve an AddressList with a IPv6 address first and then a IPv4 address.
   host_resolver_.rules()->AddIPLiteralRule(kHostName, "2:abcd::3:4:ff,2.2.2.2",
diff --git a/chromium/net/socket/udp_client_socket.h b/chromium/net/socket/udp_client_socket.h
index d8a7348c549..d576370c333 100644
--- a/chromium/net/socket/udp_client_socket.h
+++ b/chromium/net/socket/udp_client_socket.h
@@ -24,6 +24,10 @@ class NET_EXPORT_PRIVATE UDPClientSocket : public DatagramClientSocket {
   UDPClientSocket(DatagramSocket::BindType bind_type,
                   net::NetLog* net_log,
                   const net::NetLogSource& source);
+
+  UDPClientSocket(const UDPClientSocket&) = delete;
+  UDPClientSocket& operator=(const UDPClientSocket&) = delete;
+
   ~UDPClientSocket() override;
 
   // DatagramClientSocket implementation.
@@ -78,8 +82,6 @@ class NET_EXPORT_PRIVATE UDPClientSocket : public DatagramClientSocket {
  private:
   UDPSocket socket_;
   NetworkChangeNotifier::NetworkHandle network_;
-
-  DISALLOW_COPY_AND_ASSIGN(UDPClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/udp_server_socket.cc b/chromium/net/socket/udp_server_socket.cc
index eb043813b57..a2c16638349 100644
--- a/chromium/net/socket/udp_server_socket.cc
+++ b/chromium/net/socket/udp_server_socket.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "build/build_config.h"
 #include "net/base/net_errors.h"
 
 namespace net {
diff --git a/chromium/net/socket/udp_server_socket.h b/chromium/net/socket/udp_server_socket.h
index 37ba36bbab4..54456c6c1e9 100644
--- a/chromium/net/socket/udp_server_socket.h
+++ b/chromium/net/socket/udp_server_socket.h
@@ -24,6 +24,10 @@ struct NetLogSource;
 class NET_EXPORT UDPServerSocket : public DatagramServerSocket {
  public:
   UDPServerSocket(net::NetLog* net_log, const net::NetLogSource& source);
+
+  UDPServerSocket(const UDPServerSocket&) = delete;
+  UDPServerSocket& operator=(const UDPServerSocket&) = delete;
+
   ~UDPServerSocket() override;
 
   // Implement DatagramServerSocket:
@@ -61,7 +65,6 @@ class NET_EXPORT UDPServerSocket : public DatagramServerSocket {
   bool allow_address_reuse_;
   bool allow_broadcast_;
   bool allow_address_sharing_for_multicast_;
-  DISALLOW_COPY_AND_ASSIGN(UDPServerSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/udp_socket_posix.cc b/chromium/net/socket/udp_socket_posix.cc
index c34a1e72958..1a90794e04b 100644
--- a/chromium/net/socket/udp_socket_posix.cc
+++ b/chromium/net/socket/udp_socket_posix.cc
@@ -73,8 +73,7 @@ const int kPortStart = 1024;
 const int kPortEnd = 65535;
 const int kActivityMonitorBytesThreshold = 65535;
 const int kActivityMonitorMinimumSamplesForThroughputEstimate = 2;
-const base::TimeDelta kActivityMonitorMsThreshold =
-    base::TimeDelta::FromMilliseconds(100);
+const base::TimeDelta kActivityMonitorMsThreshold = base::Milliseconds(100);
 
 #if defined(OS_MAC)
 
diff --git a/chromium/net/socket/udp_socket_posix.h b/chromium/net/socket/udp_socket_posix.h
index 15aacb159af..d96b17e9fc2 100644
--- a/chromium/net/socket/udp_socket_posix.h
+++ b/chromium/net/socket/udp_socket_posix.h
@@ -66,8 +66,7 @@ struct NET_EXPORT SendResult {
 };
 
 // Don't delay writes more than this.
-const base::TimeDelta kWriteAsyncMsThreshold =
-    base::TimeDelta::FromMilliseconds(1);
+const base::TimeDelta kWriteAsyncMsThreshold = base::Milliseconds(1);
 // Prefer local if number of writes is not more than this.
 const int kWriteAsyncMinBuffersThreshold = 2;
 // Don't allow more than this many outstanding async writes.
@@ -129,6 +128,10 @@ class NET_EXPORT UDPSocketPosix {
   class ReceivedActivityMonitor {
    public:
     ReceivedActivityMonitor() : bytes_(0), increments_(0) {}
+
+    ReceivedActivityMonitor(const ReceivedActivityMonitor&) = delete;
+    ReceivedActivityMonitor& operator=(const ReceivedActivityMonitor&) = delete;
+
     ~ReceivedActivityMonitor() = default;
     // Provided by sent/received subclass.
     // Update throughput, but batch to limit overhead of net::activity_monitor.
@@ -143,12 +146,15 @@ class NET_EXPORT UDPSocketPosix {
     uint32_t bytes_;
     uint32_t increments_;
     base::RepeatingTimer timer_;
-    DISALLOW_COPY_AND_ASSIGN(ReceivedActivityMonitor);
   };
 
   UDPSocketPosix(DatagramSocket::BindType bind_type,
                  net::NetLog* net_log,
                  const net::NetLogSource& source);
+
+  UDPSocketPosix(const UDPSocketPosix&) = delete;
+  UDPSocketPosix& operator=(const UDPSocketPosix&) = delete;
+
   virtual ~UDPSocketPosix();
 
   // Opens the socket.
@@ -384,6 +390,9 @@ class NET_EXPORT UDPSocketPosix {
     explicit WriteAsyncWatcher(UDPSocketPosix* socket)
         : socket_(socket), watching_(false) {}
 
+    WriteAsyncWatcher(const WriteAsyncWatcher&) = delete;
+    WriteAsyncWatcher& operator=(const WriteAsyncWatcher&) = delete;
+
     // MessagePumpForIO::FdWatcher methods
 
     void OnFileCanReadWithoutBlocking(int /* fd */) override {}
@@ -397,8 +406,6 @@ class NET_EXPORT UDPSocketPosix {
    private:
     UDPSocketPosix* const socket_;
     bool watching_;
-
-    DISALLOW_COPY_AND_ASSIGN(WriteAsyncWatcher);
   };
 
   void IncreaseWriteAsyncOutstanding(int increment) {
@@ -431,6 +438,9 @@ class NET_EXPORT UDPSocketPosix {
    public:
     explicit ReadWatcher(UDPSocketPosix* socket) : socket_(socket) {}
 
+    ReadWatcher(const ReadWatcher&) = delete;
+    ReadWatcher& operator=(const ReadWatcher&) = delete;
+
     // MessagePumpForIO::FdWatcher methods
 
     void OnFileCanReadWithoutBlocking(int /* fd */) override;
@@ -439,14 +449,15 @@ class NET_EXPORT UDPSocketPosix {
 
    private:
     UDPSocketPosix* const socket_;
-
-    DISALLOW_COPY_AND_ASSIGN(ReadWatcher);
   };
 
   class WriteWatcher : public base::MessagePumpForIO::FdWatcher {
    public:
     explicit WriteWatcher(UDPSocketPosix* socket) : socket_(socket) {}
 
+    WriteWatcher(const WriteWatcher&) = delete;
+    WriteWatcher& operator=(const WriteWatcher&) = delete;
+
     // MessagePumpForIO::FdWatcher methods
 
     void OnFileCanReadWithoutBlocking(int /* fd */) override {}
@@ -455,8 +466,6 @@ class NET_EXPORT UDPSocketPosix {
 
    private:
     UDPSocketPosix* const socket_;
-
-    DISALLOW_COPY_AND_ASSIGN(WriteWatcher);
   };
 
   int InternalWriteAsync(CompletionOnceCallback callback,
@@ -631,8 +640,6 @@ class NET_EXPORT UDPSocketPosix {
 
   // Used for alternate writes that are posted for concurrent execution.
   base::WeakPtrFactory<UDPSocketPosix> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(UDPSocketPosix);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/udp_socket_unittest.cc b/chromium/net/socket/udp_socket_unittest.cc
index 91e72469caa..6bbf1465fee 100644
--- a/chromium/net/socket/udp_socket_unittest.cc
+++ b/chromium/net/socket/udp_socket_unittest.cc
@@ -848,14 +848,15 @@ class TestUDPSocketWin : public UDPSocketWin {
                    const net::NetLogSource& source)
       : UDPSocketWin(bind_type, net_log, source), qos_(qos) {}
 
+  TestUDPSocketWin(const TestUDPSocketWin&) = delete;
+  TestUDPSocketWin& operator=(const TestUDPSocketWin&) = delete;
+
   // Overriding GetQwaveApi causes the test class to use the injected mock
   // QwaveApi instance instead of the singleton.
   QwaveApi* GetQwaveApi() const override { return qos_; }
 
  private:
   QwaveApi* qos_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestUDPSocketWin);
 };
 
 class MockQwaveApi : public QwaveApi {
diff --git a/chromium/net/socket/udp_socket_win.cc b/chromium/net/socket/udp_socket_win.cc
index fd5991be64a..9d757dc35fa 100644
--- a/chromium/net/socket/udp_socket_win.cc
+++ b/chromium/net/socket/udp_socket_win.cc
@@ -50,6 +50,9 @@ class UDPSocketWin::Core : public base::RefCounted<Core> {
  public:
   explicit Core(UDPSocketWin* socket);
 
+  Core(const Core&) = delete;
+  Core& operator=(const Core&) = delete;
+
   // Start watching for the end of a read or write operation.
   void WatchForRead();
   void WatchForWrite();
@@ -109,8 +112,6 @@ class UDPSocketWin::Core : public base::RefCounted<Core> {
   base::win::ObjectWatcher read_watcher_;
   // |write_watcher_| watches for events from Write();
   base::win::ObjectWatcher write_watcher_;
-
-  DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 UDPSocketWin::Core::Core(UDPSocketWin* socket)
@@ -774,7 +775,6 @@ int UDPSocketWin::InternalRecvFromOverlapped(IOBuffer* buf,
   DWORD flags = 0;
   DWORD num;
   CHECK_NE(INVALID_SOCKET, socket_);
-  AssertEventNotSignaled(core_->read_overlapped_.hEvent);
   int rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr,
                        &storage.addr_len, &core_->read_overlapped_, nullptr);
   if (rv == 0) {
@@ -833,7 +833,6 @@ int UDPSocketWin::InternalSendToOverlapped(IOBuffer* buf,
 
   DWORD flags = 0;
   DWORD num;
-  AssertEventNotSignaled(core_->write_overlapped_.hEvent);
   int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags, addr,
                      storage.addr_len, &core_->write_overlapped_, nullptr);
   if (rv == 0) {
diff --git a/chromium/net/socket/udp_socket_win.h b/chromium/net/socket/udp_socket_win.h
index a75bd08f497..f8219450b59 100644
--- a/chromium/net/socket/udp_socket_win.h
+++ b/chromium/net/socket/udp_socket_win.h
@@ -70,6 +70,9 @@ class NET_EXPORT QwaveApi {
  public:
   QwaveApi();
 
+  QwaveApi(const QwaveApi&) = delete;
+  QwaveApi& operator=(const QwaveApi&) = delete;
+
   static QwaveApi* GetDefault();
 
   virtual bool qwave_supported() const;
@@ -103,8 +106,6 @@ class NET_EXPORT QwaveApi {
   AddSocketToFlowFn add_socket_to_flow_func_;
   RemoveSocketFromFlowFn remove_socket_from_flow_func_;
   SetFlowFn set_flow_func_;
-
-  DISALLOW_COPY_AND_ASSIGN(QwaveApi);
 };
 
 //-----------------------------------------------------------------------------
@@ -119,6 +120,10 @@ class NET_EXPORT QwaveApi {
 class NET_EXPORT DscpManager {
  public:
   DscpManager(QwaveApi* api, SOCKET socket);
+
+  DscpManager(const DscpManager&) = delete;
+  DscpManager& operator=(const DscpManager&) = delete;
+
   ~DscpManager();
 
   // Remembers the latest |dscp| so PrepareToSend can add remote addresses to
@@ -149,8 +154,6 @@ class NET_EXPORT DscpManager {
   // 0 means no flow has been constructed.
   QOS_FLOWID flow_id_ = 0;
   base::WeakPtrFactory<DscpManager> weak_ptr_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(DscpManager);
 };
 
 //-----------------------------------------------------------------------------
@@ -162,6 +165,10 @@ class NET_EXPORT UDPSocketWin : public base::win::ObjectWatcher::Delegate {
   UDPSocketWin(DatagramSocket::BindType bind_type,
                net::NetLog* net_log,
                const net::NetLogSource& source);
+
+  UDPSocketWin(const UDPSocketWin&) = delete;
+  UDPSocketWin& operator=(const UDPSocketWin&) = delete;
+
   ~UDPSocketWin() override;
 
   // Opens the socket.
@@ -493,8 +500,6 @@ class NET_EXPORT UDPSocketWin : public base::win::ObjectWatcher::Delegate {
   // Used to prevent null dereferences in OnObjectSignaled, when passing an
   // error to both read and write callbacks. Cleared in Close()
   base::WeakPtrFactory<UDPSocketWin> event_pending_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(UDPSocketWin);
 };
 
 //-----------------------------------------------------------------------------
diff --git a/chromium/net/socket/unix_domain_client_socket_posix.cc b/chromium/net/socket/unix_domain_client_socket_posix.cc
index 0b52332142e..a2690b3d903 100644
--- a/chromium/net/socket/unix_domain_client_socket_posix.cc
+++ b/chromium/net/socket/unix_domain_client_socket_posix.cc
@@ -12,6 +12,7 @@
 
 #include "base/check_op.h"
 #include "base/notreached.h"
+#include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/socket/socket_posix.h"
diff --git a/chromium/net/socket/unix_domain_client_socket_posix.h b/chromium/net/socket/unix_domain_client_socket_posix.h
index 2397b91f8a7..e2c34ee717b 100644
--- a/chromium/net/socket/unix_domain_client_socket_posix.h
+++ b/chromium/net/socket/unix_domain_client_socket_posix.h
@@ -34,6 +34,9 @@ class NET_EXPORT UnixDomainClientSocket : public StreamSocket {
   // UnixDomainServerSocket uses this after it accepts a connection.
   explicit UnixDomainClientSocket(std::unique_ptr<SocketPosix> socket);
 
+  UnixDomainClientSocket(const UnixDomainClientSocket&) = delete;
+  UnixDomainClientSocket& operator=(const UnixDomainClientSocket&) = delete;
+
   ~UnixDomainClientSocket() override;
 
   // Fills |address| with |socket_path| and its length. For Android or Linux
@@ -83,8 +86,6 @@ class NET_EXPORT UnixDomainClientSocket : public StreamSocket {
   // This net log is just to comply StreamSocket::NetLog(). It throws away
   // everything.
   NetLogWithSource net_log_;
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainClientSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/unix_domain_client_socket_posix_unittest.cc b/chromium/net/socket/unix_domain_client_socket_posix_unittest.cc
index 83baa128b00..55268dd713b 100644
--- a/chromium/net/socket/unix_domain_client_socket_posix_unittest.cc
+++ b/chromium/net/socket/unix_domain_client_socket_posix_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/posix/eintr_wrapper.h"
+#include "build/build_config.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/sockaddr_storage.h"
diff --git a/chromium/net/socket/unix_domain_server_socket_posix.h b/chromium/net/socket/unix_domain_server_socket_posix.h
index 9da6bc0d5d2..8d3bdf888fb 100644
--- a/chromium/net/socket/unix_domain_server_socket_posix.h
+++ b/chromium/net/socket/unix_domain_server_socket_posix.h
@@ -47,6 +47,10 @@ class NET_EXPORT UnixDomainServerSocket : public ServerSocket {
 
   UnixDomainServerSocket(const AuthCallback& auth_callack,
                          bool use_abstract_namespace);
+
+  UnixDomainServerSocket(const UnixDomainServerSocket&) = delete;
+  UnixDomainServerSocket& operator=(const UnixDomainServerSocket&) = delete;
+
   ~UnixDomainServerSocket() override;
 
   // Gets credentials of peer to check permissions.
@@ -94,8 +98,6 @@ class NET_EXPORT UnixDomainServerSocket : public ServerSocket {
     SocketDescriptor* descriptor = nullptr;
   };
   SocketDestination out_socket_;
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocket);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/websocket_endpoint_lock_manager.cc b/chromium/net/socket/websocket_endpoint_lock_manager.cc
index f1fff379c55..a405974d363 100644
--- a/chromium/net/socket/websocket_endpoint_lock_manager.cc
+++ b/chromium/net/socket/websocket_endpoint_lock_manager.cc
@@ -47,7 +47,7 @@ WebSocketEndpointLockManager::LockReleaser::~LockReleaser() {
 }
 
 WebSocketEndpointLockManager::WebSocketEndpointLockManager()
-    : unlock_delay_(base::TimeDelta::FromMilliseconds(kUnlockDelayInMs)),
+    : unlock_delay_(base::Milliseconds(kUnlockDelayInMs)),
       pending_unlock_count_(0) {}
 
 WebSocketEndpointLockManager::~WebSocketEndpointLockManager() {
diff --git a/chromium/net/socket/websocket_endpoint_lock_manager.h b/chromium/net/socket/websocket_endpoint_lock_manager.h
index cdd8e033b9d..cae36602e0e 100644
--- a/chromium/net/socket/websocket_endpoint_lock_manager.h
+++ b/chromium/net/socket/websocket_endpoint_lock_manager.h
@@ -50,6 +50,10 @@ class NET_EXPORT_PRIVATE WebSocketEndpointLockManager {
    public:
     LockReleaser(WebSocketEndpointLockManager* websocket_endpoint_lock_manager,
                  IPEndPoint endpoint);
+
+    LockReleaser(const LockReleaser&) = delete;
+    LockReleaser& operator=(const LockReleaser&) = delete;
+
     ~LockReleaser();
 
    private:
@@ -59,11 +63,14 @@ class NET_EXPORT_PRIVATE WebSocketEndpointLockManager {
     // destroyed.
     WebSocketEndpointLockManager* websocket_endpoint_lock_manager_;
     const IPEndPoint endpoint_;
-
-    DISALLOW_COPY_AND_ASSIGN(LockReleaser);
   };
 
   WebSocketEndpointLockManager();
+
+  WebSocketEndpointLockManager(const WebSocketEndpointLockManager&) = delete;
+  WebSocketEndpointLockManager& operator=(const WebSocketEndpointLockManager&) =
+      delete;
+
   ~WebSocketEndpointLockManager();
 
   // Returns OK if lock was acquired immediately, ERR_IO_PENDING if not. If the
@@ -130,8 +137,6 @@ class NET_EXPORT_PRIVATE WebSocketEndpointLockManager {
   size_t pending_unlock_count_;
 
   base::WeakPtrFactory<WebSocketEndpointLockManager> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(WebSocketEndpointLockManager);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/websocket_endpoint_lock_manager_unittest.cc b/chromium/net/socket/websocket_endpoint_lock_manager_unittest.cc
index 85d9929bd15..32022dd18e1 100644
--- a/chromium/net/socket/websocket_endpoint_lock_manager_unittest.cc
+++ b/chromium/net/socket/websocket_endpoint_lock_manager_unittest.cc
@@ -266,7 +266,7 @@ TEST_F(WebSocketEndpointLockManagerTest, UnlockEndpointIsDelayed) {
   // applied. Instead it just verifies that the whole thing took >=1ms. 1ms is
   // easily enough for normal compiles even on Android, so the fact that there
   // is a delay is still checked on every platform.
-  const base::TimeDelta unlock_delay = base::TimeDelta::FromMilliseconds(1);
+  const base::TimeDelta unlock_delay = base::Milliseconds(1);
   websocket_endpoint_lock_manager_.SetUnlockDelayForTesting(unlock_delay);
   FakeWaiter fake_waiter;
   BlockingWaiter blocking_waiter;
diff --git a/chromium/net/socket/websocket_transport_client_socket_pool.cc b/chromium/net/socket/websocket_transport_client_socket_pool.cc
index 7d32868a251..9d9851b9396 100644
--- a/chromium/net/socket/websocket_transport_client_socket_pool.cc
+++ b/chromium/net/socket/websocket_transport_client_socket_pool.cc
@@ -250,12 +250,6 @@ base::Value WebSocketTransportClientSocketPool::GetInfoAsValue(
   return dict;
 }
 
-void WebSocketTransportClientSocketPool::DumpMemoryStats(
-    base::trace_event::ProcessMemoryDump* pmd,
-    const std::string& parent_dump_absolute_name) const {
-  // Not supported.
-}
-
 bool WebSocketTransportClientSocketPool::IsStalled() const {
   return !stalled_request_queue_.empty();
 }
diff --git a/chromium/net/socket/websocket_transport_client_socket_pool.h b/chromium/net/socket/websocket_transport_client_socket_pool.h
index d82281f2d5d..ac09b01a8e0 100644
--- a/chromium/net/socket/websocket_transport_client_socket_pool.h
+++ b/chromium/net/socket/websocket_transport_client_socket_pool.h
@@ -24,12 +24,6 @@
 #include "net/socket/ssl_client_socket.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 
-namespace base {
-namespace trace_event {
-class ProcessMemoryDump;
-}
-}  // namespace base
-
 namespace net {
 
 struct CommonConnectJobParams;
@@ -45,6 +39,11 @@ class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool
       const ProxyServer& proxy_server,
       const CommonConnectJobParams* common_connect_job_params);
 
+  WebSocketTransportClientSocketPool(
+      const WebSocketTransportClientSocketPool&) = delete;
+  WebSocketTransportClientSocketPool& operator=(
+      const WebSocketTransportClientSocketPool&) = delete;
+
   ~WebSocketTransportClientSocketPool() override;
 
   // Allow another connection to be started to the IPEndPoint that this |handle|
@@ -93,9 +92,6 @@ class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool
                          const ClientSocketHandle* handle) const override;
   base::Value GetInfoAsValue(const std::string& name,
                              const std::string& type) const override;
-  void DumpMemoryStats(
-      base::trace_event::ProcessMemoryDump* pmd,
-      const std::string& parent_dump_absolute_name) const override;
 
   // HigherLayeredPool implementation.
   bool IsStalled() const override;
@@ -109,6 +105,10 @@ class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool
                        CompletionOnceCallback callback,
                        ClientSocketHandle* socket_handle,
                        const NetLogWithSource& request_net_log);
+
+    ConnectJobDelegate(const ConnectJobDelegate&) = delete;
+    ConnectJobDelegate& operator=(const ConnectJobDelegate&) = delete;
+
     ~ConnectJobDelegate() override;
 
     // ConnectJob::Delegate implementation
@@ -136,8 +136,6 @@ class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool
     std::unique_ptr<ConnectJob> connect_job_;
     ClientSocketHandle* const socket_handle_;
     const NetLogWithSource request_net_log_;
-
-    DISALLOW_COPY_AND_ASSIGN(ConnectJobDelegate);
   };
 
   // Store the arguments from a call to RequestSocket() that has stalled so we
@@ -209,8 +207,6 @@ class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool
   bool flushing_;
 
   base::WeakPtrFactory<WebSocketTransportClientSocketPool> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPool);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/websocket_transport_client_socket_pool_unittest.cc b/chromium/net/socket/websocket_transport_client_socket_pool_unittest.cc
index 0ed4fe4c433..eec70983956 100644
--- a/chromium/net/socket/websocket_transport_client_socket_pool_unittest.cc
+++ b/chromium/net/socket/websocket_transport_client_socket_pool_unittest.cc
@@ -103,6 +103,11 @@ class WebSocketTransportClientSocketPoolTest : public TestWithTaskEnvironment {
         base::TimeDelta());
   }
 
+  WebSocketTransportClientSocketPoolTest(
+      const WebSocketTransportClientSocketPoolTest&) = delete;
+  WebSocketTransportClientSocketPoolTest& operator=(
+      const WebSocketTransportClientSocketPoolTest&) = delete;
+
   ~WebSocketTransportClientSocketPoolTest() override {
     RunUntilIdle();
     // ReleaseAllConnections() calls RunUntilIdle() after releasing each
@@ -148,9 +153,6 @@ class WebSocketTransportClientSocketPoolTest : public TestWithTaskEnvironment {
   const CommonConnectJobParams common_connect_job_params_;
   WebSocketTransportClientSocketPool pool_;
   ClientSocketPoolTest test_base_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPoolTest);
 };
 
 TEST_F(WebSocketTransportClientSocketPoolTest, Basic) {
@@ -622,8 +624,8 @@ TEST_F(WebSocketTransportClientSocketPoolTest,
       MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
-  client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds(
-      TransportConnectJob::kIPv6FallbackTimerInMs + 50));
+  client_socket_factory_.set_delay(
+      base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs + 50));
 
   // Resolve an AddressList with an IPv6 address first and then an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
@@ -769,8 +771,7 @@ TEST_F(WebSocketTransportClientSocketPoolTest, IPv6RapidFail) {
   base::TimeTicks start(base::TimeTicks::Now());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_LT(base::TimeTicks::Now() - start,
-            base::TimeDelta::FromMilliseconds(
-                TransportConnectJob::kIPv6FallbackTimerInMs));
+            base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs));
   ASSERT_TRUE(handle.socket());
 
   IPEndPoint endpoint;
@@ -819,8 +820,8 @@ TEST_F(WebSocketTransportClientSocketPoolTest, FirstSuccessWins) {
 TEST_F(WebSocketTransportClientSocketPoolTest, LastFailureWins) {
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_FAILING_CLIENT_SOCKET);
-  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(
-      TransportConnectJob::kIPv6FallbackTimerInMs / 3);
+  base::TimeDelta delay =
+      base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs / 3);
   client_socket_factory_.set_delay(delay);
 
   // Resolve an AddressList with 4 IPv6 addresses and 2 IPv4 addresses.
@@ -861,8 +862,7 @@ TEST_F(WebSocketTransportClientSocketPoolTest, DISABLED_OverallTimeoutApplies) {
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_FAILING_CLIENT_SOCKET);
-  client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(1) +
-                                   connect_job_timeout / 6);
+  client_socket_factory_.set_delay(base::Seconds(1) + connect_job_timeout / 6);
 
   // Resolve an AddressList with 6 IPv6 addresses and 6 IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule("*",
@@ -1053,8 +1053,8 @@ TEST_F(WebSocketTransportClientSocketPoolTest,
   }
   // Now we have |kMaxSockets| IPv6 sockets stalled in connect. No IPv4 sockets
   // are started yet.
-  RunLoopForTimePeriod(base::TimeDelta::FromMilliseconds(
-      TransportConnectJob::kIPv6FallbackTimerInMs));
+  RunLoopForTimePeriod(
+      base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs));
   // Now we have |kMaxSockets| IPv6 sockets and one IPv4 socket stalled in
   // connect, and |kMaxSockets - 1| IPv4 sockets waiting for the endpoint lock.
   pool_.FlushWithError(ERR_FAILED, "Very good reason");
diff --git a/chromium/net/socket/websocket_transport_connect_job.cc b/chromium/net/socket/websocket_transport_connect_job.cc
index a979d064b60..0f10af6078a 100644
--- a/chromium/net/socket/websocket_transport_connect_job.cc
+++ b/chromium/net/socket/websocket_transport_connect_job.cc
@@ -151,9 +151,15 @@ int WebSocketTransportConnectJob::DoResolveHost() {
   HostResolver::ResolveHostParameters parameters;
   parameters.initial_priority = priority();
   DCHECK_EQ(SecureDnsPolicy::kAllow, params_->secure_dns_policy());
-  request_ = host_resolver()->CreateRequest(
-      ToLegacyDestinationEndpoint(params_->destination()),
-      params_->network_isolation_key(), net_log(), parameters);
+  if (absl::holds_alternative<url::SchemeHostPort>(params_->destination())) {
+    request_ = host_resolver()->CreateRequest(
+        absl::get<url::SchemeHostPort>(params_->destination()),
+        params_->network_isolation_key(), net_log(), parameters);
+  } else {
+    request_ = host_resolver()->CreateRequest(
+        absl::get<HostPortPair>(params_->destination()),
+        params_->network_isolation_key(), net_log(), parameters);
+  }
 
   return request_->Start(base::BindOnce(
       &WebSocketTransportConnectJob::OnIOComplete, base::Unretained(this)));
@@ -243,8 +249,7 @@ int WebSocketTransportConnectJob::DoTransportConnect() {
           // owned by this object.
           fallback_timer_.Start(
               FROM_HERE,
-              base::TimeDelta::FromMilliseconds(
-                  TransportConnectJob::kIPv6FallbackTimerInMs),
+              base::Milliseconds(TransportConnectJob::kIPv6FallbackTimerInMs),
               base::BindOnce(&WebSocketTransportConnectJob::StartIPv4JobAsync,
                              base::Unretained(this)));
         }
diff --git a/chromium/net/socket/websocket_transport_connect_job.h b/chromium/net/socket/websocket_transport_connect_job.h
index ab739039418..0bb6aa8cc8e 100644
--- a/chromium/net/socket/websocket_transport_connect_job.h
+++ b/chromium/net/socket/websocket_transport_connect_job.h
@@ -59,6 +59,11 @@ class NET_EXPORT_PRIVATE WebSocketTransportConnectJob : public ConnectJob {
       const scoped_refptr<TransportSocketParams>& params,
       Delegate* delegate,
       const NetLogWithSource* net_log);
+
+  WebSocketTransportConnectJob(const WebSocketTransportConnectJob&) = delete;
+  WebSocketTransportConnectJob& operator=(const WebSocketTransportConnectJob&) =
+      delete;
+
   ~WebSocketTransportConnectJob() override;
 
   // ConnectJob methods.
@@ -123,8 +128,6 @@ class NET_EXPORT_PRIVATE WebSocketTransportConnectJob : public ConnectJob {
   ResolveErrorInfo resolve_error_info_;
 
   base::WeakPtrFactory<WebSocketTransportConnectJob> weak_ptr_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(WebSocketTransportConnectJob);
 };
 
 }  // namespace net
diff --git a/chromium/net/socket/websocket_transport_connect_sub_job.cc b/chromium/net/socket/websocket_transport_connect_sub_job.cc
index 3d05d53cf6a..cfbe9e369e4 100644
--- a/chromium/net/socket/websocket_transport_connect_sub_job.cc
+++ b/chromium/net/socket/websocket_transport_connect_sub_job.cc
@@ -31,6 +31,9 @@ class WebSocketStreamSocket final : public StreamSocket {
       : wrapped_socket_(std::move(wrapped_socket)),
         lock_releaser_(websocket_endpoint_lock_manager, address) {}
 
+  WebSocketStreamSocket(const WebSocketStreamSocket&) = delete;
+  WebSocketStreamSocket& operator=(const WebSocketStreamSocket&) = delete;
+
   ~WebSocketStreamSocket() override = default;
 
   // Socket implementation:
@@ -107,9 +110,6 @@ class WebSocketStreamSocket final : public StreamSocket {
   int64_t GetTotalReceivedBytes() const override {
     return wrapped_socket_->GetTotalReceivedBytes();
   }
-  void DumpMemoryStats(SocketMemoryStats* stats) const override {
-    wrapped_socket_->DumpMemoryStats(stats);
-  }
   void ApplySocketTag(const SocketTag& tag) override {
     wrapped_socket_->ApplySocketTag(tag);
   }
@@ -117,8 +117,6 @@ class WebSocketStreamSocket final : public StreamSocket {
  private:
   std::unique_ptr<StreamSocket> wrapped_socket_;
   WebSocketEndpointLockManager::LockReleaser lock_releaser_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebSocketStreamSocket);
 };
 
 }  // namespace
diff --git a/chromium/net/socket/websocket_transport_connect_sub_job.h b/chromium/net/socket/websocket_transport_connect_sub_job.h
index 23cb529ed23..c7a1141fead 100644
--- a/chromium/net/socket/websocket_transport_connect_sub_job.h
+++ b/chromium/net/socket/websocket_transport_connect_sub_job.h
@@ -40,6 +40,11 @@ class WebSocketTransportConnectSubJob
       SubJobType type,
       WebSocketEndpointLockManager* websocket_endpoint_lock_manager);
 
+  WebSocketTransportConnectSubJob(const WebSocketTransportConnectSubJob&) =
+      delete;
+  WebSocketTransportConnectSubJob& operator=(
+      const WebSocketTransportConnectSubJob&) = delete;
+
   ~WebSocketTransportConnectSubJob() override;
 
   // Start connecting.
@@ -91,8 +96,6 @@ class WebSocketTransportConnectSubJob
   WebSocketEndpointLockManager* const websocket_endpoint_lock_manager_;
 
   std::unique_ptr<StreamSocket> transport_socket_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebSocketTransportConnectSubJob);
 };
 
 }  // namespace net
author	Allan Sandfeld Jensen <allan.jensen@qt.io>	2022-02-02 12:21:57 +0100
committer	Allan Sandfeld Jensen <allan.jensen@qt.io>	2022-02-12 08:13:00 +0000
commit	606d85f2a5386472314d39923da28c70c60dc8e7 (patch)
tree	a8f4d7bf997f349f45605e6058259fba0630e4d7 /chromium/net/socket
parent	5786336dda477d04fb98483dca1a5426eebde2d7 (diff)
download	qtwebengine-chromium-606d85f2a5386472314d39923da28c70c60dc8e7.tar.gz