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

net/http/http_auth_handler.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_AUTH_HANDLER_H_
 #define NET_HTTP_HTTP_AUTH_HANDLER_H_
 
 #include <string>
 
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/http/http_auth.h"
+#include "net/http/http_auth_cache.h"
 #include "net/log/net_log.h"
 
 namespace net {
 
 class HttpAuthChallengeTokenizer;
 struct HttpRequestInfo;
+class HttpResponseInfo;
 
 // HttpAuthHandler is the interface for the authentication schemes
 // (basic, digest, NTLM, Negotiate). Each authentication scheme is expected to
 // subclass HttpAuthHandler.
 //
 // The lifecycle of a HttpAuthHandler -- i.e. how to use HttpAuthHandler --:
 //
 // 1. Construct via HttpAuthHandlerFactory::CreateAuthHandlerForScheme() or
 //    HttpAuthHandlerFactory::CreateAndInitPreemptiveAuthHandler().
 //
@@ skipping 23 matching lines @@
 //      handshake. The AuthorizationResult return value indicates whether the
 //      handler can continue with the current authentication handshake or if it
 //      has encountered an error. A return value of AUTHORIZATION_RESULT_ACCEPT
 //      indicates that the handler can continue. In all other cases, the handler
 //      should be considered no longer usable.
 //
 class NET_EXPORT_PRIVATE HttpAuthHandler {
  public:
   virtual ~HttpAuthHandler();
 
+  int InitializeFromCacheEntry(HttpAuthCache::Entry* cache_entry,
+                               HttpAuth::Target target,
+                               const BoundNetLog& net_log);
+
   // Initializes the handler and associates it with the specified |target| and
   // |origin|. The |net_log| parameter indicates BoundNetLog to be used for the
   // lifetime of this handler. |challenge| is required and *must* match the
   // authentication scheme of this handler.
   //
   // Returns a Error value. The HttpAuthHandler can only be used if the return
   // value is OK.
   //
   // Note: This method *must* be the first method to be invoked on the
   // HttpAuthHandler.
   int HandleInitialChallenge(const HttpAuthChallengeTokenizer& challenge,
+                             const HttpResponseInfo& response_info,
                              HttpAuth::Target target,
                              const GURL& origin,
-                             const BoundNetLog& net_log);
+                             const BoundNetLog& net_log,
+                             const CompletionCallback& callback);
 
   // Generates an authentication token, potentially asynchronously.
   //
   // If NeedsIdentity() is true, then the value of |credentials| indicates how
   // the authentication identity is established.
   //
   // 1. If |credentials| is nullptr, then the handler attempts to use ambient
   //    credentials to establish an identity. Passing in a nullptr for
   //    |credentials| is only valid if AllowsDefaultCredentials() returns true.
   //
@@ skipping 87 matching lines @@
 
  protected:
   // |scheme| sets the return value for auth_scheme().
   HttpAuthHandler(const std::string& scheme);
 
   // Initializes the handler using a challenge issued by a server.  |challenge|
   // must be non-NULL and have already tokenized the authentication scheme, but
   // none of the tokens occurring after the authentication scheme.
   // Implementations are expected to initialize the following members: scheme_,
   // realm_
-  virtual int Init(const HttpAuthChallengeTokenizer& challenge) = 0;
+  //
+  // TODO(asanka): Update comment.
+  virtual int InitializeFromChallengeInternal(
+      const HttpAuthChallengeTokenizer& challenge,
+      const HttpResponseInfo& response_with_challenge,
+      const CompletionCallback& callback) = 0;
+
+  // TODO(asanka): Update comment
+  virtual int InitializeFromCacheEntryInternal(
+      HttpAuthCache::Entry* cache_entry) = 0;
 
   // |GenerateAuthTokenImpl()} is the auth-scheme specific implementation
   // of generating the next auth token. Callers should use |GenerateAuthToken()|
   // which will in turn call |GenerateAuthTokenImpl()|
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo& request,
                                     const CompletionCallback& callback,
                                     std::string* auth_token) = 0;
 
   // The auth-scheme as a lowercase ASCII RFC 2616 2.2 token.
@@ skipping 18 matching lines @@
  private:
   void OnGenerateAuthTokenComplete(int rv);
   void FinishGenerateAuthToken();
 
   CompletionCallback callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_HANDLER_H_