[net/http auth] Make HttpAuthHandler challenge handling asynchronous.

net/http/http_auth_handler_negotiate.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 "net/http/http_auth_handler_negotiate.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 24 matching lines @@
 }
 
 void HttpAuthHandlerNegotiate::Factory::set_host_resolver(
     HostResolver* resolver) {
   resolver_ = resolver;
 }
 
 scoped_ptr<HttpAuthHandler>
 HttpAuthHandlerNegotiate::Factory::CreateAndInitPreemptiveAuthHandler(
     HttpAuthCache::Entry* cache_entry,
-    const HttpAuthChallengeTokenizer& tokenizer,
     HttpAuth::Target target,
     const BoundNetLog& net_log) {
   return scoped_ptr<HttpAuthHandler>();
 }
 
 scoped_ptr<HttpAuthHandler>
 HttpAuthHandlerNegotiate::Factory::CreateAuthHandlerForScheme(
     const std::string& scheme) {
   DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
   if (scheme != "negotiate")
@@ skipping 132 matching lines @@
     return false;
   return url_security_manager_->CanUseDefaultCredentials(origin_);
 }
 
 bool HttpAuthHandlerNegotiate::AllowsExplicitCredentials() {
   return auth_system_.AllowsExplicitCredentials();
 }
 
 // The Negotiate challenge header looks like:
 //   WWW-Authenticate: NEGOTIATE auth-data
-int HttpAuthHandlerNegotiate::Init(
-    const HttpAuthChallengeTokenizer& challenge) {
+int HttpAuthHandlerNegotiate::InitializeFromChallengeInternal(
+    const HttpAuthChallengeTokenizer& challenge,
+    const HttpResponseInfo& response_with_challenge,
+    const CompletionCallback& callback) {
 #if defined(OS_POSIX)
   if (!auth_system_.Init()) {
     VLOG(1) << "can't initialize GSSAPI library";
     return ERR_UNSUPPORTED_AUTH_SCHEME;
   }
   // GSSAPI does not provide a way to enter username/password to
   // obtain a TGT. If the default credentials are not allowed for
   // a particular site (based on whitelist), fall back to a
   // different scheme.
   if (!AllowsDefaultCredentials())
     return ERR_UNSUPPORTED_AUTH_SCHEME;
 #endif
   if (CanDelegate())
     auth_system_.Delegate();
   auth_scheme_ = "negotiate";
   HttpAuth::AuthorizationResult auth_result =
       auth_system_.ParseChallenge(challenge);
   return auth_result == HttpAuth::AUTHORIZATION_RESULT_ACCEPT
              ? OK
              : ERR_INVALID_RESPONSE;
 }
 
+int HttpAuthHandlerNegotiate::InitializeFromCacheEntryInternal(
+    HttpAuthCache::Entry*) {
+  NOTREACHED();
+  return ERR_UNSUPPORTED_AUTH_SCHEME;
+}
+
 int HttpAuthHandlerNegotiate::GenerateAuthTokenImpl(
     const AuthCredentials* credentials,
     const HttpRequestInfo& request,
     const CompletionCallback& callback,
     std::string* auth_token) {
   DCHECK(callback_.is_null());
   DCHECK(auth_token_ == NULL);
   auth_token_ = auth_token;
   if (already_called_) {
     DCHECK((!has_credentials_ && credentials == NULL) ||
@@ skipping 112 matching lines @@
 bool HttpAuthHandlerNegotiate::CanDelegate() const {
   // TODO(cbentzel): Should delegation be allowed on proxies?
   if (target_ == HttpAuth::AUTH_PROXY)
     return false;
   if (!url_security_manager_)
     return false;
   return url_security_manager_->CanDelegate(origin_);
 }
 
 }  // namespace net