[net/http auth] Split HttpAuthHandler creation from initialization.

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.h"
 #include "base/strings/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_basic.h"
 #include "net/http/http_auth_handler_digest.h"
 #include "net/http/http_auth_handler_ntlm.h"
 
 #if defined(USE_KERBEROS)
 #include "net/http/http_auth_handler_negotiate.h"
 #endif
 
 namespace net {
 
-int HttpAuthHandlerFactory::CreateAuthHandlerFromString(
-    const std::string& challenge,
-    HttpAuth::Target target,
-    const GURL& origin,
-    const BoundNetLog& net_log,
-    scoped_ptr<HttpAuthHandler>* handler) {
-  HttpAuthChallengeTokenizer props(challenge.begin(), challenge.end());
-  return CreateAuthHandler(props, target, origin, CREATE_CHALLENGE, 1, net_log,
-                           handler);
-}
-
-int HttpAuthHandlerFactory::CreatePreemptiveAuthHandlerFromString(
-    const std::string& challenge,
-    HttpAuth::Target target,
-    const GURL& origin,
-    int digest_nonce_count,
-    const BoundNetLog& net_log,
-    scoped_ptr<HttpAuthHandler>* handler) {
-  HttpAuthChallengeTokenizer props(challenge.begin(), challenge.end());
-  return CreateAuthHandler(props, target, origin, CREATE_PREEMPTIVE,
-                           digest_nonce_count, net_log, handler);
-}
-
 // static
 scoped_ptr<HttpAuthHandlerRegistryFactory>
 HttpAuthHandlerFactory::CreateDefault(HostResolver* host_resolver) {
   DCHECK(host_resolver);
   scoped_ptr<HttpAuthHandlerRegistryFactory> registry_factory =
       make_scoped_ptr(new HttpAuthHandlerRegistryFactory());
   registry_factory->RegisterSchemeFactory(
       "basic", new HttpAuthHandlerBasic::Factory());
   registry_factory->RegisterSchemeFactory(
       "digest", new HttpAuthHandlerDigest::Factory());
@@ skipping 115 matching lines @@
     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);
   }
 #endif  // defined(USE_KERBEROS)
 
   return registry_factory;
 }
 
-int HttpAuthHandlerRegistryFactory::CreateAuthHandler(
-    const HttpAuthChallengeTokenizer& challenge,
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerRegistryFactory::CreateAuthHandlerForScheme(
+    const std::string& scheme) {
+  const auto it = factory_map_.find(scheme);
+  if (it == factory_map_.end())
+    return scoped_ptr<HttpAuthHandler>();
+  DCHECK(it->second);
+  return it->second->CreateAuthHandlerForScheme(scheme);
+}
+
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerRegistryFactory::CreateAndInitPreemptiveAuthHandler(
+    HttpAuthCache::Entry* cache_entry,
+    const HttpAuthChallengeTokenizer& tokenizer,
     HttpAuth::Target target,
-    const GURL& origin,
-    CreateReason reason,
-    int digest_nonce_count,
-    const BoundNetLog& net_log,
-    scoped_ptr<HttpAuthHandler>* handler) {
-  std::string scheme = challenge.NormalizedScheme();
-  if (scheme.empty()) {
-    handler->reset();
-    return ERR_INVALID_RESPONSE;
-  }
-  FactoryMap::iterator it = factory_map_.find(scheme);
-  if (it == factory_map_.end()) {
-    handler->reset();
-    return ERR_UNSUPPORTED_AUTH_SCHEME;
-  }
+    const BoundNetLog& net_log) {
+  std::string scheme_name = cache_entry->scheme();
+  const auto it = factory_map_.find(scheme_name);
+  if (it == factory_map_.end())
+    return scoped_ptr<HttpAuthHandler>();
   DCHECK(it->second);
-  return it->second->CreateAuthHandler(challenge, target, origin, reason,
-                                       digest_nonce_count, net_log, handler);
+  return it->second->CreateAndInitPreemptiveAuthHandler(cache_entry, tokenizer,
+                                                        target, net_log);
 }
 
 }  // namespace net