Remove static "set_fixed_cnonce" in favor of NonceGenerator objects....

net/http/http_auth_handler_digest.cc

 // Copyright (c) 2010 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 27 matching lines @@
 //----------+----------+------------------------------------------+
 //          | md5-sess | MD5(user:realm:password):nonce:cnonce    |
 //==========+==========+==========================================+
 //    qop   |algorithm |                  A2                      |
 //==========+==========+==========================================+
 //  ?, auth |          | req-method:req-uri                       |
 //----------+----------+------------------------------------------+
 // auth-int |          | req-method:req-uri:MD5(req-entity-body)  |
 //=====================+==========================================+
 
+HttpAuthHandlerDigest::NonceGenerator::NonceGenerator() {
+}
 
-//static
-bool HttpAuthHandlerDigest::fixed_cnonce_ = false;
+HttpAuthHandlerDigest::NonceGenerator::~NonceGenerator() {
+}
 
-// static
-std::string HttpAuthHandlerDigest::GenerateNonce() {
+HttpAuthHandlerDigest::DynamicNonceGenerator::DynamicNonceGenerator() {
+}
+
+std::string HttpAuthHandlerDigest::DynamicNonceGenerator::GenerateNonce()
+    const {
   // This is how mozilla generates their cnonce -- a 16 digit hex string.
   static const char domain[] = "0123456789abcdef";
-  if (fixed_cnonce_)
-    return std::string(domain);
   std::string cnonce;
   cnonce.reserve(16);
   for (int i = 0; i < 16; ++i)
     cnonce.push_back(domain[base::RandInt(0, 15)]);
   return cnonce;
 }
 
+HttpAuthHandlerDigest::FixedNonceGenerator::FixedNonceGenerator(
+    const std::string& nonce)
+    : nonce_(nonce) {
+}
+
+std::string HttpAuthHandlerDigest::FixedNonceGenerator::GenerateNonce() const {
+  return nonce_;
+}
+
 // static
 std::string HttpAuthHandlerDigest::QopToString(QualityOfProtection qop) {
   switch (qop) {
     case QOP_UNSPECIFIED:
       return "";
     case QOP_AUTH:
       return "auth";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 // static
 std::string HttpAuthHandlerDigest::AlgorithmToString(
     DigestAlgorithm algorithm) {
   switch (algorithm) {
     case ALGORITHM_UNSPECIFIED:
       return "";
     case ALGORITHM_MD5:
       return "MD5";
     case ALGORITHM_MD5_SESS:
       return "MD5-sess";
     default:
       NOTREACHED();
       return "";
   }
 }
 
-HttpAuthHandlerDigest::HttpAuthHandlerDigest(int nonce_count)
+HttpAuthHandlerDigest::HttpAuthHandlerDigest(
+    int nonce_count, const NonceGenerator* nonce_generator)
     : stale_(false),
       algorithm_(ALGORITHM_UNSPECIFIED),
       qop_(QOP_UNSPECIFIED),
-      nonce_count_(nonce_count) {
+      nonce_count_(nonce_count),
+      nonce_generator_(nonce_generator) {
+  DCHECK(nonce_generator_);
 }
 
 HttpAuthHandlerDigest::~HttpAuthHandlerDigest() {
 }
 
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
     const string16* username,
     const string16* password,
     const HttpRequestInfo* request,
     CompletionCallback* callback,
     std::string* auth_token) {
   // Generate a random client nonce.
-  std::string cnonce = GenerateNonce();
+  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,
@@ skipping 198 matching lines @@
         break;
       }
     }
   } else {
     DVLOG(1) << "Skipping unrecognized digest property";
     // TODO(eroman): perhaps we should fail instead of silently skipping?
   }
   return true;
 }
 
-HttpAuthHandlerDigest::Factory::Factory() {
+HttpAuthHandlerDigest::Factory::Factory()
+    : nonce_generator_(new DynamicNonceGenerator()) {
 }
 
 HttpAuthHandlerDigest::Factory::~Factory() {
 }
 
+void HttpAuthHandlerDigest::Factory::set_nonce_generator(
+    const NonceGenerator* nonce_generator) {
+  nonce_generator_.reset(nonce_generator);
+}
+
 int HttpAuthHandlerDigest::Factory::CreateAuthHandler(
     HttpAuth::ChallengeTokenizer* 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));
+      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;
 }
 
 }  // namespace net