Remove a bunch of unused network flags.

chrome/browser/io_thread.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 744 matching lines @@
   // Only handle use-spdy command line flags if "spdy.disabled" preference is
   // not disabled via policy.
   if (is_spdy_disabled_by_policy_) {
     base::FieldTrial* trial = base::FieldTrialList::Find(kSpdyFieldTrialName);
     if (trial)
       trial->Disable();
   } else {
     std::string spdy_trial_group =
         base::FieldTrialList::FindFullName(kSpdyFieldTrialName);
 
-    if (command_line.HasSwitch(switches::kEnableIPPooling))
-      globals_->enable_spdy_ip_pooling.set(true);
-
-    if (command_line.HasSwitch(switches::kDisableIPPooling))
-      globals_->enable_spdy_ip_pooling.set(false);
-
     if (command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
       // Enable WebSocket over SPDY.
       net::WebSocketJob::set_websocket_over_spdy_enabled(true);
     }
 
-    if (command_line.HasSwitch(switches::kMaxSpdyConcurrentStreams)) {
-      globals_->max_spdy_concurrent_streams_limit.set(
-          GetSwitchValueAsInt(command_line,
-                              switches::kMaxSpdyConcurrentStreams));
-    }
     if (command_line.HasSwitch(switches::kTrustedSpdyProxy)) {
       globals_->trusted_spdy_proxy.set(
           command_line.GetSwitchValueASCII(switches::kTrustedSpdyProxy));
     }
     if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
       net::URLFetcher::SetIgnoreCertificateRequests(true);
 
     if (command_line.HasSwitch(switches::kUseSpdy)) {
       std::string spdy_mode =
           command_line.GetSwitchValueASCII(switches::kUseSpdy);
       EnableSpdy(spdy_mode);
     } else if (command_line.HasSwitch(switches::kEnableHttp2Draft04)) {
       net::HttpStreamFactory::EnableNpnHttp2Draft04();
     } else if (command_line.HasSwitch(switches::kEnableSpdy4a2)) {
       net::HttpStreamFactory::EnableNpnSpdy4a2();
     } else if (command_line.HasSwitch(switches::kDisableSpdy31)) {
       net::HttpStreamFactory::EnableNpnSpdy3();
-    } else if (command_line.HasSwitch(switches::kEnableSpdy2)) {
-      net::HttpStreamFactory::EnableNpnSpdy31WithSpdy2();
     } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
       net::HttpStreamFactory::EnableNpnHttpOnly();
     } else {
       if (spdy_trial_group == kSpdyFieldTrialDisabledGroupName &&
           !command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
          net::HttpStreamFactory::set_spdy_enabled(false);
       } else {
         // Use SPDY/3.1 by default.
         net::HttpStreamFactory::EnableNpnSpdy31();
       }
@@ skipping 167 matching lines @@
       globals_->http_server_properties->GetWeakPtr();
   params->network_delegate = globals_->system_network_delegate.get();
   params->host_mapping_rules = globals_->host_mapping_rules.get();
   params->ignore_certificate_errors = globals_->ignore_certificate_errors;
   params->http_pipelining_enabled = globals_->http_pipelining_enabled;
   params->testing_fixed_http_port = globals_->testing_fixed_http_port;
   params->testing_fixed_https_port = globals_->testing_fixed_https_port;
 
   globals_->initial_max_spdy_concurrent_streams.CopyToIfSet(
       &params->spdy_initial_max_concurrent_streams);
-  globals_->max_spdy_concurrent_streams_limit.CopyToIfSet(
-      &params->spdy_max_concurrent_streams_limit);
   globals_->force_spdy_single_domain.CopyToIfSet(
       &params->force_spdy_single_domain);
-  globals_->enable_spdy_ip_pooling.CopyToIfSet(
-      &params->enable_spdy_ip_pooling);
   globals_->enable_spdy_compression.CopyToIfSet(
       &params->enable_spdy_compression);
   globals_->enable_spdy_ping_based_connection_checking.CopyToIfSet(
       &params->enable_spdy_ping_based_connection_checking);
   globals_->spdy_default_protocol.CopyToIfSet(
       &params->spdy_default_protocol);
   globals_->trusted_spdy_proxy.CopyToIfSet(
       &params->trusted_spdy_proxy);
   globals_->enable_quic.CopyToIfSet(&params->enable_quic);
   globals_->enable_quic_https.CopyToIfSet(&params->enable_quic_https);
@@ skipping 205 matching lines @@
   std::string version_flag =
       command_line.GetSwitchValueASCII(switches::kQuicVersion);
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == version_flag) {
       return version;
     }
   }
   return net::QUIC_VERSION_UNSUPPORTED;
 }