BASELINE: Update Chromium to 74.0.3729.159

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

1 files changed, 151 insertions, 52 deletions

diff --git a/chromium/net/socket/socks_connect_job_unittest.cc b/chromium/net/socket/socks_connect_job_unittest.cc
index 713fc557996..05e611531c6 100644
--- a/chromium/net/socket/socks_connect_job_unittest.cc
+++ b/chromium/net/socket/socks_connect_job_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/socket/socks_client_socket_pool.h"
+#include "net/socket/socks_connect_job.h"
 
 #include "base/callback.h"
 #include "base/containers/span.h"
@@ -10,6 +10,7 @@
 #include "base/test/scoped_task_environment.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "net/base/load_states.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
@@ -21,7 +22,6 @@
 #include "net/socket/socket_tag.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/socks_connect_job.h"
-#include "net/socket/transport_client_socket_pool.h"
 #include "net/socket/transport_connect_job.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_with_scoped_task_environment.h"
@@ -49,13 +49,7 @@ class SOCKSConnectJobTest : public testing::Test,
       : WithScopedTaskEnvironment(
             base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
             base::test::ScopedTaskEnvironment::NowSource::
-                MAIN_THREAD_MOCK_TIME),
-        transport_pool_(2 /* max_sockets */,
-                        2 /* max_sockets_per_group */,
-                        &host_resolver_,
-                        &client_socket_factory_,
-                        nullptr /* socket_performance_watcher_factory */,
-                        &net_log_) {
+                MAIN_THREAD_MOCK_TIME) {
     // Set an initial delay to ensure that the first call to TimeTicks::Now()
     // before incrementing the counter does not return a null value.
     FastForwardBy(base::TimeDelta::FromSeconds(1));
@@ -76,11 +70,21 @@ class SOCKSConnectJobTest : public testing::Test,
         TRAFFIC_ANNOTATION_FOR_TESTS);
   }
 
+  CommonConnectJobParams CreateCommonParams() {
+    // Group name doesn't matter.
+    return CommonConnectJobParams(
+        SocketTag(), &client_socket_factory_, &host_resolver_,
+        nullptr /* proxy_delegate */, SSLClientSocketContext(),
+        SSLClientSocketContext(),
+        nullptr /* socket_performance_watcher_factory */,
+        nullptr /* network_quality_estimator */, &net_log_,
+        nullptr /* websocket_endpoint_lock_manager */);
+  }
+
  protected:
   NetLog net_log_;
   MockHostResolver host_resolver_;
   MockTaggingClientSocketFactory client_socket_factory_;
-  TransportClientSocketPool transport_pool_;
 };
 
 TEST_F(SOCKSConnectJobTest, HostResolutionFailure) {
@@ -89,10 +93,9 @@ TEST_F(SOCKSConnectJobTest, HostResolutionFailure) {
   for (bool failure_synchronous : {false, true}) {
     host_resolver_.set_synchronous_mode(failure_synchronous);
     TestConnectJobDelegate test_delegate;
-    SOCKSConnectJob socks_connect_job(
-        kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-        true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-        &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+    SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                      CreateSOCKSParams(SOCKSVersion::V5),
+                                      &test_delegate, nullptr /* net_log */);
     test_delegate.StartJobExpectingResult(
         &socks_connect_job, ERR_PROXY_CONNECTION_FAILED, failure_synchronous);
   }
@@ -118,10 +121,9 @@ TEST_F(SOCKSConnectJobTest, HandshakeError) {
       client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
 
       TestConnectJobDelegate test_delegate;
-      SOCKSConnectJob socks_connect_job(
-          kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-          true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-          &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+      SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V5),
+                                        &test_delegate, nullptr /* net_log */);
       test_delegate.StartJobExpectingResult(
           &socks_connect_job, ERR_UNEXPECTED,
           host_resolution_synchronous && write_failure_synchronous);
@@ -152,10 +154,9 @@ TEST_F(SOCKSConnectJobTest, SOCKS4) {
       client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
 
       TestConnectJobDelegate test_delegate;
-      SOCKSConnectJob socks_connect_job(
-          kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-          true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V4),
-          &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+      SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V4),
+                                        &test_delegate, nullptr /* net_log */);
       test_delegate.StartJobExpectingResult(
           &socks_connect_job, OK,
           host_resolution_synchronous && read_and_writes_synchronous);
@@ -189,10 +190,9 @@ TEST_F(SOCKSConnectJobTest, SOCKS5) {
       client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
 
       TestConnectJobDelegate test_delegate;
-      SOCKSConnectJob socks_connect_job(
-          kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-          true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-          &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+      SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V5),
+                                        &test_delegate, nullptr /* net_log */);
       test_delegate.StartJobExpectingResult(
           &socks_connect_job, OK,
           host_resolution_synchronous && read_and_writes_synchronous);
@@ -200,6 +200,46 @@ TEST_F(SOCKSConnectJobTest, SOCKS5) {
   }
 }
 
+TEST_F(SOCKSConnectJobTest, HasEstablishedConnection) {
+  host_resolver_.set_ondemand_mode(true);
+  MockWrite writes[] = {
+      MockWrite(ASYNC, kSOCKS4OkRequestLocalHostPort80,
+                kSOCKS4OkRequestLocalHostPort80Length, 0),
+  };
+
+  MockRead reads[] = {
+      MockRead(ASYNC, ERR_IO_PENDING, 1),
+      MockRead(ASYNC, kSOCKS4OkReply, kSOCKS4OkReplyLength, 2),
+  };
+
+  SequencedSocketData sequenced_socket_data(reads, writes);
+  sequenced_socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
+
+  TestConnectJobDelegate test_delegate;
+  SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                    CreateSOCKSParams(SOCKSVersion::V4),
+                                    &test_delegate, nullptr /* net_log */);
+  socks_connect_job.Connect();
+  EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, socks_connect_job.GetLoadState());
+  EXPECT_FALSE(socks_connect_job.HasEstablishedConnection());
+
+  host_resolver_.ResolveNow(1);
+  EXPECT_EQ(LOAD_STATE_CONNECTING, socks_connect_job.GetLoadState());
+  EXPECT_FALSE(socks_connect_job.HasEstablishedConnection());
+
+  sequenced_socket_data.RunUntilPaused();
+  // "LOAD_STATE_CONNECTING" is also returned when negotiating a SOCKS
+  // connection.
+  EXPECT_EQ(LOAD_STATE_CONNECTING, socks_connect_job.GetLoadState());
+  EXPECT_TRUE(socks_connect_job.HasEstablishedConnection());
+  EXPECT_FALSE(test_delegate.has_result());
+
+  sequenced_socket_data.Resume();
+  EXPECT_THAT(test_delegate.WaitForResult(), test::IsOk());
+  EXPECT_TRUE(test_delegate.has_result());
+}
+
 // Check that TransportConnectJob's timeout is respected for the nested
 // TransportConnectJob.
 TEST_F(SOCKSConnectJobTest, TimeoutDuringDnsResolution) {
@@ -207,10 +247,9 @@ TEST_F(SOCKSConnectJobTest, TimeoutDuringDnsResolution) {
   host_resolver_.set_ondemand_mode(true);
 
   TestConnectJobDelegate test_delegate;
-  SOCKSConnectJob socks_connect_job(
-      kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-      true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-      &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+  SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                    CreateSOCKSParams(SOCKSVersion::V5),
+                                    &test_delegate, nullptr /* net_log */);
   socks_connect_job.Connect();
 
   // Just before the TransportConnectJob's timeout, nothing should have
@@ -222,7 +261,6 @@ TEST_F(SOCKSConnectJobTest, TimeoutDuringDnsResolution) {
   // Wait for exactly the TransportConnectJob's timeout to have passed. The Job
   // should time out.
   FastForwardBy(kTinyTime);
-  EXPECT_FALSE(host_resolver_.has_pending_requests());
   EXPECT_TRUE(test_delegate.has_result());
   EXPECT_THAT(test_delegate.WaitForResult(),
               test::IsError(ERR_PROXY_CONNECTION_FAILED));
@@ -246,10 +284,9 @@ TEST_F(SOCKSConnectJobTest, TimeoutDuringHandshake) {
   client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
 
   TestConnectJobDelegate test_delegate;
-  SOCKSConnectJob socks_connect_job(
-      kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-      true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-      &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+  SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                    CreateSOCKSParams(SOCKSVersion::V5),
+                                    &test_delegate, nullptr /* net_log */);
   socks_connect_job.Connect();
 
   // Just before the TransportConnectJob's timeout, nothing should have
@@ -283,9 +320,6 @@ TEST_F(SOCKSConnectJobTest, TimeoutDuringHandshake) {
 // modified.
 TEST_F(SOCKSConnectJobTest, Priority) {
   host_resolver_.set_ondemand_mode(true);
-  // Make resolution eventually fail, so old jobs can easily be removed from the
-  // socket pool.
-  host_resolver_.rules()->AddSimulatedFailure(kProxyHostName);
   for (int initial_priority = MINIMUM_PRIORITY;
        initial_priority <= MAXIMUM_PRIORITY; ++initial_priority) {
     for (int new_priority = MINIMUM_PRIORITY; new_priority <= MAXIMUM_PRIORITY;
@@ -295,10 +329,9 @@ TEST_F(SOCKSConnectJobTest, Priority) {
         continue;
       TestConnectJobDelegate test_delegate;
       SOCKSConnectJob socks_connect_job(
-          kSOCKS5TestHost /* group_name */,
-          static_cast<RequestPriority>(initial_priority), SocketTag(),
-          true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V4),
-          &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+          static_cast<RequestPriority>(initial_priority), CreateCommonParams(),
+          CreateSOCKSParams(SOCKSVersion::V4), &test_delegate,
+          nullptr /* net_log */);
       ASSERT_THAT(socks_connect_job.Connect(), test::IsError(ERR_IO_PENDING));
       ASSERT_TRUE(host_resolver_.has_pending_requests());
       int request_id = host_resolver_.num_resolve();
@@ -313,12 +346,6 @@ TEST_F(SOCKSConnectJobTest, Priority) {
       socks_connect_job.ChangePriority(
           static_cast<RequestPriority>(initial_priority));
       EXPECT_EQ(initial_priority, host_resolver_.request_priority(request_id));
-
-      // Complete the resolution, which should result in emptying the
-      // TransportSocketPool.
-      host_resolver_.ResolveAllPending();
-      ASSERT_THAT(test_delegate.WaitForResult(),
-                  test::IsError(ERR_PROXY_CONNECTION_FAILED));
     }
   }
 }
@@ -347,10 +374,9 @@ TEST_F(SOCKSConnectJobTest, ConnectTiming) {
   client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
 
   TestConnectJobDelegate test_delegate;
-  SOCKSConnectJob socks_connect_job(
-      kSOCKS5TestHost /* group_name */, DEFAULT_PRIORITY, SocketTag(),
-      true /* respect_limits */, CreateSOCKSParams(SOCKSVersion::V5),
-      &transport_pool_, &host_resolver_, &test_delegate, &net_log_);
+  SOCKSConnectJob socks_connect_job(DEFAULT_PRIORITY, CreateCommonParams(),
+                                    CreateSOCKSParams(SOCKSVersion::V5),
+                                    &test_delegate, nullptr /* net_log */);
   base::TimeTicks start = base::TimeTicks::Now();
   socks_connect_job.Connect();
 
@@ -381,5 +407,78 @@ TEST_F(SOCKSConnectJobTest, ConnectTiming) {
   EXPECT_EQ(base::TimeTicks(), socks_connect_job.connect_timing().ssl_end);
 }
 
+TEST_F(SOCKSConnectJobTest, CancelDuringDnsResolution) {
+  // Set HostResolver to hang.
+  host_resolver_.set_ondemand_mode(true);
+
+  TestConnectJobDelegate test_delegate;
+  std::unique_ptr<SOCKSConnectJob> socks_connect_job =
+      std::make_unique<SOCKSConnectJob>(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V5),
+                                        &test_delegate, nullptr /* net_log */);
+  socks_connect_job->Connect();
+
+  EXPECT_TRUE(host_resolver_.has_pending_requests());
+
+  socks_connect_job.reset();
+  RunUntilIdle();
+  EXPECT_FALSE(host_resolver_.has_pending_requests());
+  EXPECT_FALSE(test_delegate.has_result());
+}
+
+TEST_F(SOCKSConnectJobTest, CancelDuringConnect) {
+  host_resolver_.set_synchronous_mode(true);
+
+  SequencedSocketData sequenced_socket_data{base::span<MockRead>(),
+                                            base::span<MockWrite>()};
+  sequenced_socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
+
+  TestConnectJobDelegate test_delegate;
+  std::unique_ptr<SOCKSConnectJob> socks_connect_job =
+      std::make_unique<SOCKSConnectJob>(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V5),
+                                        &test_delegate, nullptr /* net_log */);
+  socks_connect_job->Connect();
+  // Host resolution should resolve immediately. The ConnectJob should currently
+  // be trying to connect.
+  EXPECT_FALSE(host_resolver_.has_pending_requests());
+
+  socks_connect_job.reset();
+  RunUntilIdle();
+  EXPECT_FALSE(test_delegate.has_result());
+  // Socket should have been destroyed.
+  EXPECT_FALSE(sequenced_socket_data.socket());
+}
+
+TEST_F(SOCKSConnectJobTest, CancelDuringHandshake) {
+  host_resolver_.set_synchronous_mode(true);
+
+  // Hang at start of handshake.
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 0),
+  };
+  SequencedSocketData sequenced_socket_data(base::span<MockRead>(), writes);
+  sequenced_socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
+  client_socket_factory_.AddSocketDataProvider(&sequenced_socket_data);
+
+  TestConnectJobDelegate test_delegate;
+  std::unique_ptr<SOCKSConnectJob> socks_connect_job =
+      std::make_unique<SOCKSConnectJob>(DEFAULT_PRIORITY, CreateCommonParams(),
+                                        CreateSOCKSParams(SOCKSVersion::V5),
+                                        &test_delegate, nullptr /* net_log */);
+  socks_connect_job->Connect();
+  // Host resolution should resolve immediately. The socket connecting, and the
+  // ConnectJob should currently be trying to send the SOCKS handshake.
+  EXPECT_FALSE(host_resolver_.has_pending_requests());
+
+  socks_connect_job.reset();
+  RunUntilIdle();
+  EXPECT_FALSE(test_delegate.has_result());
+  // Socket should have been destroyed.
+  EXPECT_FALSE(sequenced_socket_data.socket());
+  EXPECT_TRUE(sequenced_socket_data.AllWriteDataConsumed());
+}
+
 }  // namespace
 }  // namespace net