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

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 74 matching lines @@
 
 HttpAuthHandlerDigest::Factory::~Factory() {
 }
 
 void HttpAuthHandlerDigest::Factory::set_nonce_generator(
     const NonceGenerator* nonce_generator) {
   nonce_generator_.reset(nonce_generator);
 }
 
 int HttpAuthHandlerDigest::Factory::CreateAuthHandler(
-    HttpAuthChallengeTokenizer* challenge,
+    const HttpAuthChallengeTokenizer& challenge,
     HttpAuth::Target target,
     const GURL& origin,
     CreateReason reason,
     int digest_nonce_count,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
   // TODO(cbentzel): Move towards model of parsing in the factory
   //                 method and only constructing when valid.
   scoped_ptr<HttpAuthHandler> tmp_handler(
       new HttpAuthHandlerDigest(digest_nonce_count, nonce_generator_.get()));
-  if (!tmp_handler->InitFromChallenge(challenge, target, origin, net_log))
-    return ERR_INVALID_RESPONSE;
-  handler->swap(tmp_handler);
-  return OK;
+  int result =
+      tmp_handler->HandleInitialChallenge(challenge, target, origin, net_log);
+  if (result == OK)
+    handler->swap(tmp_handler);
+  return result;
 }
 
 HttpAuth::AuthorizationResult HttpAuthHandlerDigest::HandleAnotherChallenge(
-    HttpAuthChallengeTokenizer* challenge) {
+    const HttpAuthChallengeTokenizer& challenge) {
   // Even though Digest is not connection based, a "second round" is parsed
   // to differentiate between stale and rejected responses.
   // Note that the state of the current handler is not mutated - this way if
   // there is a rejection the realm hasn't changed.
-  if (!challenge->SchemeIs(kDigestSchemeName))
+  if (!challenge.SchemeIs(kDigestSchemeName))
     return HttpAuth::AUTHORIZATION_RESULT_INVALID;
 
-  HttpUtil::NameValuePairsIterator parameters = challenge->param_pairs();
+  HttpUtil::NameValuePairsIterator parameters = challenge.param_pairs();
 
   // Try to find the "stale" value, and also keep track of the realm
   // for the new challenge.
   std::string original_realm;
   while (parameters.GetNext()) {
     if (base::LowerCaseEqualsASCII(parameters.name(), "stale")) {
       if (base::LowerCaseEqualsASCII(parameters.value(), "true"))
         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;
 }
 
-bool HttpAuthHandlerDigest::Init(HttpAuthChallengeTokenizer* challenge) {
-  return ParseChallenge(challenge);
+int HttpAuthHandlerDigest::Init(const HttpAuthChallengeTokenizer& challenge) {
+  return ParseChallenge(challenge) ? OK : ERR_INVALID_RESPONSE;
 }
 
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
-    const AuthCredentials* credentials, const HttpRequestInfo* request,
-    const CompletionCallback& callback, std::string* auth_token) {
+    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.
   std::string method;
   std::string path;
   GetRequestMethodAndPath(request, &method, &path);
 
   *auth_token = AssembleCredentials(method, path, *credentials,
@@ skipping 26 matching lines @@
 //     [<extension-directive>]
 //
 // Note that according to RFC 2617 (section 1.2) the realm is required.
 // However we allow it to be omitted, in which case it will default to the
 // empty string.
 //
 // This allowance is for better compatibility with webservers that fail to
 // send the realm (See http://crbug.com/20984 for an instance where a
 // webserver was not sending the realm with a BASIC challenge).
 bool HttpAuthHandlerDigest::ParseChallenge(
-    HttpAuthChallengeTokenizer* challenge) {
+    const HttpAuthChallengeTokenizer& challenge) {
   auth_scheme_ = kDigestSchemeName;
 
   // Initialize to defaults.
   stale_ = false;
   algorithm_ = ALGORITHM_UNSPECIFIED;
   qop_ = QOP_UNSPECIFIED;
   realm_ = original_realm_ = nonce_ = domain_ = opaque_ = std::string();
 
   // FAIL -- Couldn't match auth-scheme.
-  if (!challenge->SchemeIs(kDigestSchemeName))
+  if (!challenge.SchemeIs(kDigestSchemeName))
     return false;
 
-  HttpUtil::NameValuePairsIterator parameters = challenge->param_pairs();
+  HttpUtil::NameValuePairsIterator parameters = challenge.param_pairs();
 
   // Loop through all the properties.
   while (parameters.GetNext()) {
     // FAIL -- couldn't parse a property.
     if (!ParseChallengeProperty(parameters.name(),
                                 parameters.value()))
       return false;
   }
 
   // Check if tokenizer failed.
@@ skipping 75 matching lines @@
       return "MD5";
     case ALGORITHM_MD5_SESS:
       return "MD5-sess";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 void HttpAuthHandlerDigest::GetRequestMethodAndPath(
-    const HttpRequestInfo* request,
+    const HttpRequestInfo& request,
     std::string* method,
     std::string* path) const {
-  DCHECK(request);
-
-  const GURL& url = request->url;
+  const GURL& url = request.url;
 
   if (target_ == HttpAuth::AUTH_PROXY &&
       (url.SchemeIs("https") || url.SchemeIsWSOrWSS())) {
     *method = "CONNECT";
     *path = GetHostAndPort(url);
   } else {
-    *method = request->method;
+    *method = request.method;
     *path = url.PathForRequest();
   }
 }
 
 std::string HttpAuthHandlerDigest::AssembleResponseDigest(
     const std::string& method,
     const std::string& path,
     const AuthCredentials& credentials,
     const std::string& cnonce,
     const std::string& nc) const {
@@ skipping 50 matching lines @@
     // TODO(eroman): Supposedly IIS server requires quotes surrounding qop.
     authorization += ", qop=" + QopToString(qop_);
     authorization += ", nc=" + nc;
     authorization += ", cnonce=" + HttpUtil::Quote(cnonce);
   }
 
   return authorization;
 }
 
 }  // namespace net