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 170 matching lines @@
     if (base::StringToInt(s, &n) && n >= 0) {
       options.max_retry_attempts = static_cast<size_t>(n);
     } else {
       LOG(ERROR) << "Invalid switch for host resolver retry attempts: " << s;
     }
   }
 
   scoped_ptr<net::HostResolver> global_host_resolver(
       net::HostResolver::CreateSystemResolver(options, net_log));
 
-  // Determine if we should disable IPv6 support.
-  if (command_line.HasSwitch(switches::kEnableIPv6)) {
-    // Disable IPv6 probing.
-    global_host_resolver->SetDefaultAddressFamily(
-        net::ADDRESS_FAMILY_UNSPECIFIED);
-  } else if (command_line.HasSwitch(switches::kDisableIPv6)) {
+  if (command_line.HasSwitch(switches::kDisableIPv6)) {

[szym, 2014/02/19 00:13:29]

IMO if anything deserves to be left behind, it is --enable-ipv6.

If Chrome incorrectly disables IPv6, users cannot reach local IPv6-only
resources, so --enable-ipv6 is a last resort workaround.

In contrast, if Chrome incorrectly enables IPv6, it costs a few hundred
milliseconds in performance for every new socket. I don't think people will
bother to use the command-line flag to work around such a performance problem.

[willchan no longer on Chromium, 2014/02/19 00:21:43]

Oh, maybe I got this wrong. Did you think we should move *both* to
net-internals? Or just one and remove the other completely? I'm open to
whatever.

[szym, 2014/02/19 02:29:16]

In contrast to -async-dns (which can be moved to net-internals), we do not have
a persistent preference (in chrome://flags or group policy) that would allow
users to override this, so I'd prefer to leave --enable-ipv6 command line flag.

     global_host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
   }
 
   // If hostname remappings were specified on the command-line, layer these
   // rules on top of the real host resolver. This allows forwarding all requests
   // through a designated test server.
   if (!command_line.HasSwitch(switches::kHostResolverRules))
     return global_host_resolver.PassAs<net::HostResolver>();
 
   scoped_ptr<net::MappedHostResolver> remapped_resolver(
@@ skipping 559 matching lines @@
       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);
@@ skipping 209 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;
 }