Partial changes to enable net-internals in iOS.

chrome/browser/net/connection_tester.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/net/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "net/http/http_server_properties_impl.h"
 #include "net/proxy/dhcp_proxy_script_fetcher_factory.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/proxy/proxy_service_v8.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_storage.h"
 
-#if !defined(OS_ANDROID)
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
 #include "chrome/browser/importer/firefox_proxy_settings.h"
 #endif
 
 namespace {
 
 // ExperimentURLRequestContext ------------------------------------------------
 
 // An instance of ExperimentURLRequestContext is created for each experiment
 // run by ConnectionTester. The class initializes network dependencies according
 // to the specified "experiment".
@@ skipping 50 matching lines @@
     scoped_ptr<net::ProxyService> experiment_proxy_service;
     rv = CreateProxyService(experiment.proxy_settings_experiment,
                             proxy_config_service, &experiment_proxy_service);
     if (rv != net::OK)
       return rv;  // Failure.
     storage_.set_proxy_service(experiment_proxy_service.release());
 
     // The rest of the dependencies are standard, and don't depend on the
     // experiment being run.
     storage_.set_cert_verifier(net::CertVerifier::CreateDefault());
+#if !defined(DISABLE_FTP_SUPPORT)
     storage_.set_ftp_transaction_factory(
         new net::FtpNetworkLayer(host_resolver()));
+#endif
     storage_.set_ssl_config_service(new net::SSLConfigServiceDefaults);
     storage_.set_http_auth_handler_factory(
         net::HttpAuthHandlerFactory::CreateDefault(host_resolver()));
     storage_.set_http_server_properties(new net::HttpServerPropertiesImpl);
 
     net::HttpNetworkSession::Params session_params;
     session_params.host_resolver = host_resolver();
     session_params.cert_verifier = cert_verifier();
     session_params.proxy_service = proxy_service();
     session_params.ssl_config_service = ssl_config_service();
@@ skipping 65 matching lines @@
       // Rather than falling-back to some other implementation, fail.
       return net::ERR_NOT_IMPLEMENTED;
     }
 
     net::DhcpProxyScriptFetcherFactory dhcp_factory;
     if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kDisableDhcpWpad)) {
       dhcp_factory.set_enabled(false);
     }
 
+#if defined(OS_IOS)
+    experiment_proxy_service->reset(
+        net::ProxyService::CreateUsingSystemProxyResolver(
+            proxy_config_service->release(), 0u, NULL));
+#else
     experiment_proxy_service->reset(
         net::CreateProxyServiceUsingV8ProxyResolver(
             proxy_config_service->release(),
             0u,
             new net::ProxyScriptFetcherImpl(proxy_request_context_),
             dhcp_factory.Create(proxy_request_context_),
             host_resolver(),
             NULL,
             NULL));
+#endif
 
     return net::OK;
   }
 
   // Creates a proxy config service that pulls from the system proxy settings.
   // On success returns net::OK and fills |config_service| with a new pointer.
   // Otherwise returns a network error code.
   int CreateSystemProxyConfigService(
       scoped_ptr<net::ProxyConfigService>* config_service) {
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
     // TODO(eroman): This is not supported on Linux yet, because of how
     // construction needs ot happen on the UI thread.
     return net::ERR_NOT_IMPLEMENTED;
 #else
     config_service->reset(
         net::ProxyService::CreateSystemProxyConfigService(
             base::ThreadTaskRunnerHandle::Get(), NULL));
     return net::OK;
 #endif
   }
 
-#if !defined(OS_ANDROID)
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   static int FirefoxProxySettingsTask(
       FirefoxProxySettings* firefox_settings) {
     if (!FirefoxProxySettings::GetSettings(firefox_settings))
       return net::ERR_FILE_NOT_FOUND;
     return net::OK;
   }
 
   void FirefoxProxySettingsReply(
       scoped_ptr<net::ProxyConfigService>* config_service,
       FirefoxProxySettings* firefox_settings,
@@ skipping 14 matching lines @@
   }
 #endif
 
   // Creates a fixed proxy config service that is initialized using Firefox's
   // current proxy settings. On success returns net::OK and fills
   // |config_service| with a new pointer. Otherwise returns a network error
   // code.
   int CreateFirefoxProxyConfigService(
       scoped_ptr<net::ProxyConfigService>* config_service,
       base::Callback<void(int)> callback) {
-#if defined(OS_ANDROID)
-    // Chrome on Android does not support Firefox settings.
+#if defined(OS_ANDROID) || defined(OS_IOS)
+    // Chrome on Android and IOS do not support Firefox settings.

[stuartmorgan, 2012/12/12 10:36:21]

iOS (IOS is to the iOS platform as ANDROID is to the Android platform: something
you'd never call it except when you specifically need all-caps)

[ramant (doing other things), 2012/12/12 18:25:50]

Done.

     return net::ERR_NOT_IMPLEMENTED;
 #else
     // Fetch Firefox's proxy settings (can fail if Firefox is not installed).
     FirefoxProxySettings* ff_settings = new FirefoxProxySettings();
     base::Callback<int(void)> task = base::Bind(
         &FirefoxProxySettingsTask, ff_settings);
     base::Callback<void(int)> reply = base::Bind(
         &ExperimentURLRequestContext::FirefoxProxySettingsReply,
         weak_factory_.GetWeakPtr(), config_service,
         base::Owned(ff_settings), callback);
@@ skipping 252 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }