HttpAuthHandlerFactory::CreateDefault requires a HostResolver argument.

net/http/http_auth_handler_factory.cc

 // Copyright (c) 2010 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 "net/http/http_auth_handler_factory.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_filter.h"
@@ skipping 21 matching lines @@
     const GURL& origin,
     int digest_nonce_count,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
   HttpAuth::ChallengeTokenizer props(challenge.begin(), challenge.end());
   return CreateAuthHandler(&props, target, origin, CREATE_PREEMPTIVE,
                            digest_nonce_count, net_log, handler);
 }
 
 // static
-HttpAuthHandlerRegistryFactory* HttpAuthHandlerFactory::CreateDefault() {
+HttpAuthHandlerRegistryFactory* HttpAuthHandlerFactory::CreateDefault(
+    HostResolver* host_resolver) {
+  DCHECK(host_resolver);
   HttpAuthHandlerRegistryFactory* registry_factory =
       new HttpAuthHandlerRegistryFactory();
   registry_factory->RegisterSchemeFactory(
       "basic", new HttpAuthHandlerBasic::Factory());
   registry_factory->RegisterSchemeFactory(
       "digest", new HttpAuthHandlerDigest::Factory());
-  registry_factory->RegisterSchemeFactory(
-      "negotiate", new HttpAuthHandlerNegotiate::Factory());
+  HttpAuthHandlerNegotiate::Factory* negotiate_factory =
+      new HttpAuthHandlerNegotiate::Factory();
+  negotiate_factory->set_host_resolver(host_resolver);
+  registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
   registry_factory->RegisterSchemeFactory(
       "ntlm", new HttpAuthHandlerNTLM::Factory());
   return registry_factory;
 }
 
 namespace {
 
 bool IsSupportedScheme(const std::vector<std::string>& supported_schemes,
                        const std::string& scheme) {
   std::vector<std::string>::const_iterator it = std::find(
@@ skipping 21 matching lines @@
   if (IsSupportedScheme(supported_schemes, "ntlm")) {
     HttpAuthHandlerNTLM::Factory* ntlm_factory =
         new HttpAuthHandlerNTLM::Factory();
     ntlm_factory->set_url_security_manager(security_manager);
     registry_factory->RegisterSchemeFactory("ntlm", ntlm_factory);
   }
   if (IsSupportedScheme(supported_schemes, "negotiate")) {
     HttpAuthHandlerNegotiate::Factory* negotiate_factory =
         new HttpAuthHandlerNegotiate::Factory();
     negotiate_factory->set_url_security_manager(security_manager);
-    DCHECK(host_resolver != NULL || negotiate_disable_cname_lookup);
+    DCHECK(host_resolver || negotiate_disable_cname_lookup);
     negotiate_factory->set_host_resolver(host_resolver);
     negotiate_factory->set_disable_cname_lookup(negotiate_disable_cname_lookup);
     negotiate_factory->set_use_port(negotiate_enable_port);
     registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
   }
 
   return registry_factory;
 }
 
 HttpAuthHandlerRegistryFactory::HttpAuthHandlerRegistryFactory() {
@@ skipping 53 matching lines @@
     const std::string& scheme) const {
   std::string lower_scheme = StringToLowerASCII(scheme);
   FactoryMap::const_iterator it = factory_map_.find(lower_scheme);
   if (it == factory_map_.end()) {
     return NULL;                  // |scheme| is not registered.
   }
   return it->second;
 }
 
 }  // namespace net