Support the MaxConnectionsPerProxy Policy when using Network Service.

Bug: 972125
Change-Id: Ieba22ac128dbb4c6e24e1ff417a84c5e4f775605
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1660966Reviewed-by: Robbie McElrath <rmcelrath@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Eric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#670297}

chrome/browser/browser_process_impl.cc

@@ -135,8 +135,6 @@
 #include "extensions/buildflags/buildflags.h"
 #include "extensions/common/constants.h"
 #include "media/media_buildflags.h"
-#include "net/socket/client_socket_pool_manager.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "ppapi/buildflags/buildflags.h"
 #include "printing/buildflags/buildflags.h"
 #include "services/network/public/cpp/features.h"
@@ -320,13 +318,6 @@ void BrowserProcessImpl::Init() {
                              base::Bind(&ApplyMetricsReportingPolicy));
 #endif
 
-  int max_per_proxy = local_state_->GetInteger(prefs::kMaxConnectionsPerProxy);
-  net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(
-      net::HttpNetworkSession::NORMAL_SOCKET_POOL,
-      std::max(std::min(max_per_proxy, 99),
-               net::ClientSocketPoolManager::max_sockets_per_group(
-                   net::HttpNetworkSession::NORMAL_SOCKET_POOL)));
-
   DCHECK(!webrtc_event_log_manager_);
   webrtc_event_log_manager_ = WebRtcEventLogManager::CreateSingletonInstance();
 
@@ -909,10 +900,6 @@ prefs::InProcessPrefServiceFactory* BrowserProcessImpl::pref_service_factory()
 void BrowserProcessImpl::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kDefaultBrowserSettingEnabled,
                                 false);
-  // This policy needs to be defined before the net subsystem is initialized,
-  // so we do it here.
-  registry->RegisterIntegerPref(prefs::kMaxConnectionsPerProxy,
-                                net::kDefaultMaxSocketsPerProxyServer);
 
   registry->RegisterBooleanPref(prefs::kAllowCrossOriginAuthPrompt, false);
 

chrome/browser/net/system_network_context_manager.cc

@@ -477,6 +477,8 @@ void SystemNetworkContextManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kEnableReferrers, true);
 
   registry->RegisterBooleanPref(prefs::kQuickCheckEnabled, true);
+
+  registry->RegisterIntegerPref(prefs::kMaxConnectionsPerProxy, -1);
 }
 
 void SystemNetworkContextManager::OnNetworkServiceCreated(
@@ -533,6 +535,11 @@ void SystemNetworkContextManager::OnNetworkServiceCreated(
          "text/csv"});
   }
 
+  int max_connections_per_proxy =
+      local_state_->GetInteger(prefs::kMaxConnectionsPerProxy);
+  if (max_connections_per_proxy != -1)
+    network_service->SetMaxConnectionsPerProxy(max_connections_per_proxy);
+
   // The system NetworkContext must be created first, since it sets
   // |primary_network_context| to true.
   network_service->CreateNetworkContext(

services/network/network_service.cc

@@ -41,6 +41,7 @@
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_util.h"
 #include "net/nqe/network_quality_estimator.h"
+#include "net/socket/client_socket_pool_manager.h"
 #include "net/ssl/ssl_key_logger_impl.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
@@ -544,6 +545,22 @@ void NetworkService::SetRawHeadersAccess(
   }
 }
 
+void NetworkService::SetMaxConnectionsPerProxy(int32_t max_connections) {
+  int new_limit = max_connections;
+  if (new_limit < 0)
+    new_limit = net::kDefaultMaxSocketsPerProxyServer;
+
+  // Clamp the value between min_limit and max_limit.
+  int max_limit = 99;
+  int min_limit = net::ClientSocketPoolManager::max_sockets_per_group(
+      net::HttpNetworkSession::NORMAL_SOCKET_POOL);
+  new_limit = std::max(std::min(new_limit, max_limit), min_limit);
+
+  // Assign the global limit.
+  net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+      net::HttpNetworkSession::NORMAL_SOCKET_POOL, new_limit);
+}
+
 bool NetworkService::HasRawHeadersAccess(uint32_t process_id,
                                          const GURL& resource_url) const {
   // Allow raw headers for browser-initiated requests.

services/network/network_service.h

@@ -159,6 +159,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkService
       mojom::HttpAuthDynamicParamsPtr http_auth_dynamic_params) override;
   void SetRawHeadersAccess(uint32_t process_id,
                            const std::vector<url::Origin>& origins) override;
+  void SetMaxConnectionsPerProxy(int32_t max_connections) override;
   void GetNetworkChangeManager(
       mojom::NetworkChangeManagerRequest request) override;
   void GetNetworkQualityEstimatorManager(

services/network/network_service_unittest.cc

@@ -31,6 +31,7 @@
 #include "net/http/http_auth_scheme.h"
 #include "net/net_buildflags.h"
 #include "net/proxy_resolution/proxy_config.h"
+#include "net/socket/client_socket_pool_manager.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
@@ -603,6 +604,42 @@ TEST_F(NetworkServiceTest, AuthAndroidNegotiateAccountType) {
 }
 #endif  // defined(OS_ANDROID)
 
+static int GetGlobalMaxConnectionsPerProxy() {
+  return net::ClientSocketPoolManager::max_sockets_per_proxy_server(
+      net::HttpNetworkSession::NORMAL_SOCKET_POOL);
+}
+
+// Tests that NetworkService::SetMaxConnectionsPerProxy() (1) modifies globals
+// in net::ClientSocketPoolManager (2) saturates out of bound values.
+TEST_F(NetworkServiceTest, SetMaxConnectionsPerProxy) {
+  const int kDefault = net::kDefaultMaxSocketsPerProxyServer;
+  const int kMin = 6;
+  const int kMax = 99;
+
+  // Starts off at default value.
+  EXPECT_EQ(net::kDefaultMaxSocketsPerProxyServer,
+            GetGlobalMaxConnectionsPerProxy());
+
+  // Anything less than kMin saturates to kMin.
+  service()->SetMaxConnectionsPerProxy(kMin - 1);
+  EXPECT_EQ(kMin, GetGlobalMaxConnectionsPerProxy());
+
+  // Anything larger than kMax saturates to kMax
+  service()->SetMaxConnectionsPerProxy(kMax + 1);
+  EXPECT_EQ(kMax, GetGlobalMaxConnectionsPerProxy());
+
+  // Anything in between kMin and kMax should be set exactly.
+  service()->SetMaxConnectionsPerProxy(58);
+  EXPECT_EQ(58, GetGlobalMaxConnectionsPerProxy());
+
+  // Negative values select the default.
+  service()->SetMaxConnectionsPerProxy(-2);
+  EXPECT_EQ(kDefault, GetGlobalMaxConnectionsPerProxy());
+
+  // Restore the default value to minize sideffects.
+  service()->SetMaxConnectionsPerProxy(kDefault);
+}
+
 class NetworkServiceTestWithService : public testing::Test {
  public:
   NetworkServiceTestWithService()

services/network/public/mojom/network_service.mojom

@@ -343,6 +343,12 @@ interface NetworkService {
   // (e.g. DevTools attached).
   SetRawHeadersAccess(uint32 process_id, array<url.mojom.Origin> origins);
 
+  // Sets the maximum number of connections for a proxy server.
+  //   * Negative values will set the default proxy connection limit (32)
+  //   * Values larger than 99 will saturate to 99.
+  //   * Values smaller than 6 will saturate to 6.
+  SetMaxConnectionsPerProxy(int32 max_connections);
+
   // Gets the NetworkChangeManager.
   GetNetworkChangeManager(
       NetworkChangeManager& network_change_manager);