Use AuthCredentials throughout the network stack instead of username/password.

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/i18n/icu_string_conversions.h"
 #include "base/logging.h"
@@ skipping 119 matching lines @@
   return (original_realm_ != original_realm) ?
       HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM :
       HttpAuth::AUTHORIZATION_RESULT_REJECT;
 }
 
 bool HttpAuthHandlerDigest::Init(HttpAuth::ChallengeTokenizer* challenge) {
   return ParseChallenge(challenge);
 }
 
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
-    const string16* username,
-    const string16* password,
+    const AuthCredentials* credentials,
     const HttpRequestInfo* request,
     OldCompletionCallback* 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,
-                                    *username,
-                                    *password,
+  *auth_token = AssembleCredentials(method, path, *credentials,
                                     cnonce, nonce_count_);
   return OK;
 }
 
 HttpAuthHandlerDigest::HttpAuthHandlerDigest(
     int nonce_count, const NonceGenerator* nonce_generator)
     : stale_(false),
       algorithm_(ALGORITHM_UNSPECIFIED),
       qop_(QOP_UNSPECIFIED),
       nonce_count_(nonce_count),
@@ skipping 146 matching lines @@
     *path = GetHostAndPort(url);
   } else {
     *method = request->method;
     *path = HttpUtil::PathForRequest(url);
   }
 }
 
 std::string HttpAuthHandlerDigest::AssembleResponseDigest(
     const std::string& method,
     const std::string& path,
-    const string16& username,
-    const string16& password,
+    const AuthCredentials& credentials,
     const std::string& cnonce,
     const std::string& nc) const {
   // ha1 = MD5(A1)
   // TODO(eroman): is this the right encoding?
-  std::string ha1 = base::MD5String(UTF16ToUTF8(username) + ":" +
+  std::string ha1 = base::MD5String(UTF16ToUTF8(credentials.username()) + ":" +
                                     original_realm_ + ":" +
-                                    UTF16ToUTF8(password));
+                                    UTF16ToUTF8(credentials.password()));
   if (algorithm_ == HttpAuthHandlerDigest::ALGORITHM_MD5_SESS)
     ha1 = base::MD5String(ha1 + ":" + nonce_ + ":" + cnonce);
 
   // ha2 = MD5(A2)
   // TODO(eroman): need to add MD5(req-entity-body) for qop=auth-int.
   std::string ha2 = base::MD5String(method + ":" + path);
 
   std::string nc_part;
   if (qop_ != HttpAuthHandlerDigest::QOP_UNSPECIFIED) {
     nc_part = nc + ":" + cnonce + ":" + QopToString(qop_) + ":";
   }
 
   return base::MD5String(ha1 + ":" + nonce_ + ":" + nc_part + ha2);
 }
 
 std::string HttpAuthHandlerDigest::AssembleCredentials(
     const std::string& method,
     const std::string& path,
-    const string16& username,
-    const string16& password,
+    const AuthCredentials& credentials,
     const std::string& cnonce,
     int nonce_count) const {
   // the nonce-count is an 8 digit hex string.
   std::string nc = base::StringPrintf("%08x", nonce_count);
 
   // TODO(eroman): is this the right encoding?
   std::string authorization = (std::string("Digest username=") +
-                               HttpUtil::Quote(UTF16ToUTF8(username)));
+                               HttpUtil::Quote(
+                                   UTF16ToUTF8(credentials.username())));
   authorization += ", realm=" + HttpUtil::Quote(original_realm_);
   authorization += ", nonce=" + HttpUtil::Quote(nonce_);
   authorization += ", uri=" + HttpUtil::Quote(path);
 
   if (algorithm_ != ALGORITHM_UNSPECIFIED) {
     authorization += ", algorithm=" + AlgorithmToString(algorithm_);
   }
-  std::string response = AssembleResponseDigest(method, path, username,
-                                                password, cnonce, nc);
+  std::string response = AssembleResponseDigest(method, path, credentials,
+                                                cnonce, nc);
   // No need to call HttpUtil::Quote() as the response digest cannot contain
   // any characters needing to be escaped.
   authorization += ", response=\"" + response + "\"";
 
   if (!opaque_.empty()) {
     authorization += ", opaque=" + HttpUtil::Quote(opaque_);
   }
   if (qop_ != QOP_UNSPECIFIED) {
     // 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