[net/http auth] Cleanup. Method names, and constness.

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"
@@ skipping 12 matching lines @@
 class NET_EXPORT_PRIVATE HttpAuthHandler {
  public:
   HttpAuthHandler();
   virtual ~HttpAuthHandler();
 
   // 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. |target| and |origin| are both stored
   // for later use, and are not part of the initial challenge.
-  bool InitFromChallenge(HttpAuthChallengeTokenizer* challenge,
-                         HttpAuth::Target target,
-                         const GURL& origin,
-                         const BoundNetLog& net_log);
+  int HandleInitialChallenge(const HttpAuthChallengeTokenizer& challenge,
+                             HttpAuth::Target target,
+                             const GURL& origin,
+                             const BoundNetLog& net_log);
 
   // Determines how the previous authorization attempt was received.
   //
   // This is called when the server/proxy responds with a 401/407 after an
   // earlier authorization attempt. Although this normally means that the
   // previous attempt was rejected, in multi-round schemes such as
   // NTLM+Negotiate it may indicate that another round of challenge+response
   // is required. For Digest authentication it may also mean that the previous
   // attempt used a stale nonce (and nonce-count) and that a new attempt should
   // be made with a different nonce provided in the challenge.
   //
   // |challenge| must be non-NULL and have already tokenized the
   // authentication scheme, but none of the tokens occurring after the
   // authentication scheme.
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) = 0;
+      const HttpAuthChallengeTokenizer& challenge) = 0;
 
   // Generates an authentication token, potentially asynchronously.
   //
   // When |credentials| is NULL, the default credentials for the currently
   // logged in user are used. |AllowsDefaultCredentials()| MUST be true in this
   // case.
   //
   // |request|, |callback|, and |auth_token| must be non-NULL.
   //
   // The return value is a net error code.
   //
   // If |OK| is returned, |*auth_token| is filled in with an authentication
   // token which can be inserted in the HTTP request.
   //
   // If |ERR_IO_PENDING| is returned, |*auth_token| will be filled in
   // asynchronously and |callback| will be invoked. The lifetime of
   // |request|, |callback|, and |auth_token| must last until |callback| is
   // invoked, but |credentials| is only used during the initial call.
   //
   // All other return codes indicate that there was a problem generating a
   // token, and the value of |*auth_token| is unspecified.
   int GenerateAuthToken(const AuthCredentials* credentials,
-                        const HttpRequestInfo* request,
+                        const HttpRequestInfo& request,
                         const CompletionCallback& callback,
                         std::string* auth_token);
 
   // The authentication scheme as an enumerated value.
   const std::string& auth_scheme() const { return auth_scheme_; }
 
   // The realm, encoded as UTF-8. This may be empty.
   const std::string& realm() const {
     return realm_;
   }
@@ skipping 12 matching lines @@
     return origin_;
   }
 
   // Returns true if the response to the current authentication challenge
   // requires an identity.
   // TODO(wtc): Find a better way to handle a multi-round challenge-response
   // sequence used by a connection-based authentication scheme.
   virtual bool NeedsIdentity();
 
   // Returns whether the default credentials may be used for the |origin| passed
-  // into |InitFromChallenge|. If true, the user does not need to be prompted
-  // for username and password to establish credentials.
-  // NOTE: SSO is a potential security risk.
+  // into |HandleInitialChallenge|. If true, the user does not need to be
+  // prompted for username and password to establish credentials.  NOTE: SSO is
+  // a potential security risk.
   // TODO(cbentzel): Add a pointer to Firefox documentation about risk.
   virtual bool AllowsDefaultCredentials();
 
   // Returns whether explicit credentials can be used with this handler.  If
   // true the user may be prompted for credentials if an implicit identity
   // cannot be determined.
   virtual bool AllowsExplicitCredentials();
 
  protected:
-  // 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 bool Init(HttpAuthChallengeTokenizer* challenge) = 0;
+  // 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;
 
   // |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 HttpRequestInfo& request,
                                     const CompletionCallback& callback,
                                     std::string* auth_token) = 0;
 
   // The auth-scheme as a lowercase ASCII RFC 2616 2.2 token.
   std::string auth_scheme_;
 
   // The realm, encoded as UTF-8. Used by "basic" and "digest".
   std::string realm_;
 
   // The auth challenge.
@@ skipping 12 matching lines @@
  private:
   void OnGenerateAuthTokenComplete(int rv);
   void FinishGenerateAuthToken();
 
   CompletionCallback callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_HANDLER_H_