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 "android_webview/common/pref_names.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_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) {
+scoped_ptr<net::MappedHostResolver> CreateCmdLineConfiguredHostResolver() {
+  // 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)));

[Bernhard Bauer, 2015/11/10 17:51:29]

Use nullptr rather than NULL.

[dgn, 2015/11/11 12:26:36]

Done.

+
   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());
   }
+
+  return host_resolver;
 }
 
 void ApplyCmdlineOverridesToNetworkSessionParams(
     net::HttpNetworkSession::Params* params) {
   int value;
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
     base::StringToInt(command_line.GetSwitchValueASCII(
         switches::kTestingFixedHttpPort), &value);
@@ skipping 93 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_);
 
   net::URLRequestContextBuilder builder;
+  scoped_ptr<net::MappedHostResolver> host_resolver(
+      CreateCmdLineConfiguredHostResolver());
   scoped_ptr<AwNetworkDelegate> aw_network_delegate(new AwNetworkDelegate());
 
   AwBrowserContext* browser_context = AwBrowserContext::GetDefault();
   DCHECK(browser_context);
 
   builder.set_network_delegate(
       browser_context->GetDataReductionProxyIOData()
           ->CreateNetworkDelegate(
               aw_network_delegate.Pass(),
               false /* No UMA is produced to track bypasses. */)
           .Pass());
 #if !defined(DISABLE_FTP_SUPPORT)
   builder.set_ftp_enabled(false);  // Android WebView does not support ftp yet.
 #endif
   DCHECK(proxy_config_service_.get());
   // Android provides a local HTTP proxy that handles all the proxying.
   // Create the proxy without a resolver since we rely on this local HTTP proxy.
   // TODO(sgurun) is this behavior guaranteed through SDK?
   builder.set_proxy_service(net::ProxyService::CreateWithoutProxyResolver(
       proxy_config_service_.Pass(), net_log_.get()));
   builder.set_net_log(net_log_.get());
   builder.SetCookieAndChannelIdStores(cookie_store_, NULL);
-  ApplyCmdlineOverridesToURLRequestContextBuilder(&builder);
+  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();
   // TODO(mnaganov): Fix URLRequestContextBuilder to use proper threads.
   net::HttpNetworkSession::Params network_session_params;
 
   PopulateNetworkSessionParams(url_request_context_.get(),
                                &network_session_params);
 
   http_network_session_.reset(
       new net::HttpNetworkSession(network_session_params));
@@ skipping 43 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::HttpAuthHandlerNegotiate::Factory>
+AwURLRequestContextGetter::CreateNegotiateAuthHandlerFactory(
+    net::HostResolver* 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*/));
+
+  DCHECK(resolver);
+  scoped_ptr<net::HttpAuthHandlerNegotiate::Factory> negotiate_factory(
+      new net::HttpAuthHandlerNegotiate::Factory());
+  negotiate_factory->set_library(&auth_android_negotiate_account_type_);
+  negotiate_factory->set_host_resolver(resolver);
+  negotiate_factory->set_url_security_manager(url_security_manager_.get());
+
+  return negotiate_factory;
+}
+
 }  // namespace android_webview