SPDY proxy authentication support.

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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/net/async_dns_field_trial.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
 #include "chrome/browser/net/load_time_stats.h"
 #include "chrome/browser/net/pref_proxy_config_tracker.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
+#include "chrome/browser/net/spdyproxy/http_auth_handler_spdyproxy.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/default_server_bound_cert_store.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/host_resolver.h"
@@ skipping 399 matching lines @@
       NULL,
       NULL);
   if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
     network_delegate->NeverThrottleRequests();
   globals_->system_network_delegate.reset(network_delegate);
   globals_->host_resolver.reset(
       CreateGlobalHostResolver(net_log_));
   globals_->cert_verifier.reset(net::CertVerifier::CreateDefault());
   globals_->transport_security_state.reset(new net::TransportSecurityState());
   globals_->ssl_config_service = GetSSLConfigService();
+  if (command_line.HasSwitch(switches::kSpdyProxyOrigin)) {
+    spdyproxy_origin_ =
+        command_line.GetSwitchValueASCII(switches::kSpdyProxyOrigin);
+  }
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
   globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl);
   // For the ProxyScriptFetcher, we use a direct ProxyService.
   globals_->proxy_script_fetcher_proxy_service.reset(
       net::ProxyService::CreateDirectWithNetLog(net_log_));
   // In-memory cookie store.
   globals_->system_cookie_store = new net::CookieMonster(NULL, NULL);
   // In-memory server bound cert store.
   globals_->system_server_bound_cert_service.reset(
@@ skipping 121 matching lines @@
 
   delete globals_;
   globals_ = NULL;
 
   base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
 }
 
 // static
 void IOThread::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterStringPref(prefs::kAuthSchemes,
-                                  "basic,digest,ntlm,negotiate");
+                                  "basic,digest,ntlm,negotiate,"
+                                  "spdyproxy");
   local_state->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup,
                                    false);
   local_state->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort, false);
   local_state->RegisterStringPref(prefs::kAuthServerWhitelist, "");
   local_state->RegisterStringPref(prefs::kAuthNegotiateDelegateWhitelist, "");
   local_state->RegisterStringPref(prefs::kGSSAPILibraryName, "");
+  local_state->RegisterStringPref(prefs::kSpdyProxyOrigin, "");
   local_state->RegisterBooleanPref(prefs::kEnableReferrers, true);
 }
 
 net::HttpAuthHandlerFactory* IOThread::CreateDefaultAuthHandlerFactory(
     net::HostResolver* resolver) {
   net::HttpAuthFilterWhitelist* auth_filter_default_credentials = NULL;
   if (!auth_server_whitelist_.empty()) {
     auth_filter_default_credentials =
         new net::HttpAuthFilterWhitelist(auth_server_whitelist_);
   }
   net::HttpAuthFilterWhitelist* auth_filter_delegate = NULL;
   if (!auth_delegate_whitelist_.empty()) {
     auth_filter_delegate =
         new net::HttpAuthFilterWhitelist(auth_delegate_whitelist_);
   }
   globals_->url_security_manager.reset(
       net::URLSecurityManager::Create(auth_filter_default_credentials,
                                       auth_filter_delegate));
   std::vector<std::string> supported_schemes;
   base::SplitString(auth_schemes_, ',', &supported_schemes);
 
-  return net::HttpAuthHandlerRegistryFactory::Create(
-      supported_schemes,
-      globals_->url_security_manager.get(),
-      resolver,
-      gssapi_library_name_,
-      negotiate_disable_cname_lookup_,
-      negotiate_enable_port_);
+  scoped_ptr<net::HttpAuthHandlerRegistryFactory> registry_factory(
+      net::HttpAuthHandlerRegistryFactory::Create(
+          supported_schemes, globals_->url_security_manager.get(),
+          resolver, gssapi_library_name_, negotiate_disable_cname_lookup_,
+          negotiate_enable_port_));
+
+  if (!spdyproxy_origin_.empty()) {
+    GURL origin_url(spdyproxy_origin_);
+    if (origin_url.is_valid()) {
+      registry_factory->RegisterSchemeFactory(
+          "spdyproxy",
+          new spdyproxy::HttpAuthHandlerSpdyProxy::Factory(origin_url));
+    } else {
+      LOG(WARNING) << "Skipping creation of SpdyProxy auth handler since "
+                   << "authorized origin is invalid: "
+                   << spdyproxy_origin_;
+    }
+  }
+
+  return registry_factory.release();
 }
 
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->clear();
 }
 
@@ skipping 71 matching lines @@
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
   globals_->system_request_context.reset(
       ConstructSystemRequestContext(globals_, net_log_));
 
   sdch_manager_->set_sdch_fetcher(
       new SdchDictionaryFetcher(system_url_request_context_getter_.get()));
 }