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

net/http/http_auth_handler_digest.cc

 // Copyright (c) 2011 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_digest.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/md5.h"
@@ skipping 88 matching lines @@
         return HttpAuth::AUTHORIZATION_RESULT_STALE;
     } else if (base::LowerCaseEqualsASCII(parameters.name(), "realm")) {
       original_realm = parameters.value();
     }
   }
   return (original_realm_ != original_realm) ?
       HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM :
       HttpAuth::AUTHORIZATION_RESULT_REJECT;
 }
 
-int HttpAuthHandlerDigest::Init(const HttpAuthChallengeTokenizer& challenge) {
+int HttpAuthHandlerDigest::InitializeFromChallengeInternal(
+    const HttpAuthChallengeTokenizer& challenge,
+    const HttpResponseInfo&,
+    const CompletionCallback&) {
   return ParseChallenge(challenge) ? OK : ERR_INVALID_RESPONSE;
 }
 
+int HttpAuthHandlerDigest::InitializeFromCacheEntryInternal(
+    HttpAuthCache::Entry* cache_entry) {
+  HttpAuthChallengeTokenizer challenge(cache_entry->auth_challenge().begin(),
+                                       cache_entry->auth_challenge().end());
+  return ParseChallenge(challenge) ? OK : ERR_INVALID_RESPONSE;
+}
+
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
     const AuthCredentials* credentials,
     const HttpRequestInfo& request,
     const CompletionCallback& callback,
     std::string* auth_token) {
   // Generate a random client nonce.
   std::string cnonce = nonce_generator_->GenerateNonce();
 
   // Extract the request method and path -- the meaning of 'path' is overloaded
   // in certain cases, to be a hostname.
@@ skipping 242 matching lines @@
     const std::string& scheme) {
   DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
   if (scheme != kDigestSchemeName)
     return scoped_ptr<HttpAuthHandler>();
   return make_scoped_ptr(new HttpAuthHandlerDigest(1, nonce_generator_.get()));
 }
 
 scoped_ptr<HttpAuthHandler>
 HttpAuthHandlerDigest::Factory::CreateAndInitPreemptiveAuthHandler(
     HttpAuthCache::Entry* cache_entry,
-    const HttpAuthChallengeTokenizer& tokenizer,
     HttpAuth::Target target,
     const BoundNetLog& net_log) {
   if (cache_entry->scheme() != kDigestSchemeName)
     return scoped_ptr<HttpAuthHandler>();
   scoped_ptr<HttpAuthHandler> handler(new HttpAuthHandlerDigest(
       cache_entry->IncrementNonceCount(), nonce_generator_.get()));
-  int rv = handler->HandleInitialChallenge(tokenizer, target,
-                                           cache_entry->origin(), net_log);
+  int rv = handler->InitializeFromCacheEntry(cache_entry, target, net_log);
   if (rv == OK)
     return handler;
   return scoped_ptr<HttpAuthHandler>();
 }
 
 }  // namespace net