Add Kerberos support to webview

android_webview/browser/net/aw_url_request_context_getter.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 "android_webview/browser/net/aw_url_request_context_getter.h"
 
 #include <vector>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_content_browser_client.h"
 #include "android_webview/browser/net/aw_http_user_agent_settings.h"
 #include "android_webview/browser/net/aw_network_delegate.h"
 #include "android_webview/browser/net/aw_request_interceptor.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/init_native_callback.h"
 #include "android_webview/common/aw_content_client.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/cache_type.h"
 #include "net/cookies/cookie_store.h"
 #include "net/dns/mapped_host_resolver.h"
+#include "net/http/http_auth_filter.h"
+#include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_stream_factory.h"
+#include "net/http/url_security_manager.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/next_proto.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
 
 using content::BrowserThread;
 
 namespace android_webview {
 
 
 namespace {
 
-void ApplyCmdlineOverridesToURLRequestContextBuilder(
-    net::URLRequestContextBuilder* builder) {
+void ApplyCmdlineOverridesToHostResolver(
+    net::MappedHostResolver* host_resolver) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kHostResolverRules)) {
     // 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.
-    scoped_ptr<net::MappedHostResolver> host_resolver(
-        new net::MappedHostResolver(
-            net::HostResolver::CreateDefaultResolver(NULL)));
     host_resolver->SetRulesFromString(
         command_line.GetSwitchValueASCII(switches::kHostResolverRules));
-    builder->set_host_resolver(host_resolver.Pass());
   }
 }
 
 void ApplyCmdlineOverridesToNetworkSessionParams(
     net::URLRequestContextBuilder::HttpNetworkSessionParams* params) {
   int value;
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
     base::StringToInt(command_line.GetSwitchValueASCII(
@@ skipping 74 matching lines @@
         job_factory.Pass(), make_scoped_ptr(*i)));
   }
   request_interceptors.weak_clear();
 
   return job_factory.Pass();
 }
 
 }  // namespace
 
 AwURLRequestContextGetter::AwURLRequestContextGetter(
-    const base::FilePath& cache_path, net::CookieStore* cookie_store,
-    scoped_ptr<net::ProxyConfigService> config_service)
+    const base::FilePath& cache_path,
+    net::CookieStore* cookie_store,
+    scoped_ptr<net::ProxyConfigService> config_service,
+    PrefService* user_pref_service)
     : cache_path_(cache_path),
       net_log_(new net::NetLog()),
       proxy_config_service_(config_service.Pass()),
       cookie_store_(cookie_store),
-      http_user_agent_settings_(new AwHttpUserAgentSettings()) {
+      http_user_agent_settings_(new AwHttpUserAgentSettings()),
+      auth_android_negotiate_account_type_(user_pref_service->GetString(
+          prefs::kAuthAndroidNegotiateAccountType)),
+      auth_server_whitelist_(
+          user_pref_service->GetString(prefs::kAuthServerWhitelist)) {
   // CreateSystemProxyConfigService for Android must be called on main thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 AwURLRequestContextGetter::~AwURLRequestContextGetter() {
 }
 
 void AwURLRequestContextGetter::InitializeURLRequestContext() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!url_request_context_);
@@ skipping 29 matching lines @@
   cache_params.path = cache_path_;
   builder.EnableHttpCache(cache_params);
   builder.SetFileTaskRunner(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 
   net::URLRequestContextBuilder::HttpNetworkSessionParams
       network_session_params;
   ApplyCmdlineOverridesToNetworkSessionParams(&network_session_params);
   builder.set_http_network_session_params(network_session_params);
   builder.SetSpdyAndQuicEnabled(true, true);
-  ApplyCmdlineOverridesToURLRequestContextBuilder(&builder);
+
+  scoped_ptr<net::MappedHostResolver> host_resolver(new net::MappedHostResolver(
+      net::HostResolver::CreateDefaultResolver(nullptr)));
+  ApplyCmdlineOverridesToHostResolver(host_resolver.get());
+  builder.add_http_auth_handler_factory(
+      "negotiate",
+      CreateNegotiateAuthHandlerFactory(host_resolver.get()).release());
+  builder.set_host_resolver(host_resolver.Pass());
+
   url_request_context_ = builder.Build().Pass();
 
   job_factory_ = CreateJobFactory(&protocol_handlers_,
                                   request_interceptors_.Pass());
   job_factory_.reset(new net::URLRequestInterceptingJobFactory(
       job_factory_.Pass(),
       browser_context->GetDataReductionProxyIOData()->CreateInterceptor()));
   url_request_context_->set_job_factory(job_factory_.get());
   url_request_context_->set_http_user_agent_settings(
       http_user_agent_settings_.get());
@@ skipping 22 matching lines @@
 net::NetLog* AwURLRequestContextGetter::GetNetLog() {
   return net_log_.get();
 }
 
 void AwURLRequestContextGetter::SetKeyOnIO(const std::string& key) {
   DCHECK(AwBrowserContext::GetDefault()->GetDataReductionProxyIOData());
   AwBrowserContext::GetDefault()->GetDataReductionProxyIOData()->
       request_options()->SetKeyOnIO(key);
 }
 
+scoped_ptr<net::HttpAuthHandlerFactory>
+AwURLRequestContextGetter::CreateNegotiateAuthHandlerFactory(
+    net::HostResolver* resolver) {
+  DCHECK(resolver);
+
+  net::HttpAuthFilterWhitelist* auth_filter_default_credentials = nullptr;
+  if (!auth_server_whitelist_.empty()) {
+    auth_filter_default_credentials =
+        new net::HttpAuthFilterWhitelist(auth_server_whitelist_);
+  }
+
+  url_security_manager_.reset(net::URLSecurityManager::Create(
+      auth_filter_default_credentials, nullptr /*auth_filter_delegate*/));
+
+  std::vector<std::string> supported_schemes = {"negotiate"};
+  scoped_ptr<net::HttpAuthHandlerFactory> negotiate_factory(
+      net::HttpAuthHandlerRegistryFactory::Create(
+          supported_schemes,
+          url_security_manager_.get(),
+          resolver,
+          std::string() /* gssapi_library_name - not used on android */,
+          auth_android_negotiate_account_type_ ,
+          false /* negotiate_disable_cname_lookup - unsupported policy */,
+          false /* negotiate_enable_port - unsupported policy */));
+
+  return negotiate_factory;
+}
+
 }  // namespace android_webview