Introduce a policy to control the maximal number of connections per proxy server.

chrome/browser/net/net_pref_observer.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/net/net_pref_observer.h"
 
 #include "base/task.h"
 #include "chrome/browser/net/predictor_api.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/trials/http_throttling_trial.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_type.h"
 #include "content/common/notification_details.h"
 #include "net/http/http_stream_factory.h"
+#include "net/socket/client_socket_pool_manager.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace {
 
 // Function (for NewRunnableFunction) to call the set_enforce_throttling
 // member on the URLRequestThrottlerManager singleton.
 void SetEnforceThrottlingOnThrottlerManager(bool enforce) {
   net::URLRequestThrottlerManager::GetInstance()->set_enforce_throttling(
       enforce);
 }
 
 }
 
 NetPrefObserver::NetPrefObserver(PrefService* prefs,
                                  prerender::PrerenderManager* prerender_manager)
     : prerender_manager_(prerender_manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs);
   network_prediction_enabled_.Init(prefs::kNetworkPredictionEnabled, prefs,
                                    this);
   spdy_disabled_.Init(prefs::kDisableSpdy, prefs, this);
   http_throttling_enabled_.Init(prefs::kHttpThrottlingEnabled, prefs, this);
+  max_connections_per_proxy_.Init(prefs::kMaxConnectionsPerProxy, prefs, this);
 
   ApplySettings(NULL);
 }
 
 NetPrefObserver::~NetPrefObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void NetPrefObserver::Observe(NotificationType type,
                               const NotificationSource& source,
@@ skipping 11 matching lines @@
   if (prerender_manager_)
     prerender_manager_->set_enabled(*network_prediction_enabled_);
   net::HttpStreamFactory::set_spdy_enabled(!*spdy_disabled_);
 
   if (!pref_name || *pref_name == prefs::kHttpThrottlingEnabled) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableFunction(SetEnforceThrottlingOnThrottlerManager,
                             *http_throttling_enabled_));
   }
+
+  if (!pref_name || *pref_name == prefs::kMaxConnectionsPerProxy) {

[willchan no longer on Chromium, 2011/06/29 22:54:55]

There are a few issues here. First, this is only safe to run on the UI thread
before the IO thread has started. Otherwise, it needs to run on the IO thread.
Also, it doesn't work dynamically. The global is only read when creating the
socket pools, which only happens when a profile is created. Is that ok?

[pastarmovj, 2011/07/01 18:52:44]

Ok i removed the dynamic marking from the policy and the observer for it. So it
will only be set once on browser boot.

+    // Make sure the value is not greater than 100 and nor smaller than the
+    // maximal number of connections allowed per group.
+    net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+        std::max(std::min(*max_connections_per_proxy_, 100),
+                 net::ClientSocketPoolManager::max_sockets_per_group()));
+  }
 }
 
 // static
 void NetPrefObserver::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kNetworkPredictionEnabled,
                              true,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kDisableSpdy,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kHttpThrottlingEnabled,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kHttpThrottlingMayExperiment,
                              true,
                              PrefService::UNSYNCABLE_PREF);
-
+  prefs->RegisterIntegerPref(prefs::kMaxConnectionsPerProxy,
+                             32,

[willchan no longer on Chromium, 2011/06/29 22:54:55]

This should probably use a default that is read from net/. Perhaps you should
take the value of 32 from client_socket_pool_manager.cc and make it a global
named constant, so it can be used here.

[pastarmovj, 2011/07/01 18:52:44]

Done.

+                             PrefService::UNSYNCABLE_PREF);
   // This is the earliest point at which we can set up the trial, as
   // it relies on prefs for parameterization.
   CreateHttpThrottlingTrial(prefs);
 }