[net/http auth] Split HttpAuthHandler creation from initialization.

net/http/http_auth_handler_basic.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_basic.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_string_util.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 
 namespace net {
 
 namespace {
 
-const char* const kBasicSchemeName = "basic";
+const char kBasicSchemeName[] = "basic";
 
 // Parses a realm from an auth challenge, and converts to UTF8-encoding.
 // Returns whether the realm is invalid or the parameters are invalid.
 //
 // Note that if a realm was not specified, we will default it to "";
 // so specifying 'Basic realm=""' is equivalent to 'Basic'.
 //
 // This is more generous than RFC 2617, which is pretty clear in the
 // production of challenge that realm is required.
 //
@@ skipping 16 matching lines @@
     if (!ConvertToUtf8AndNormalize(parameters.value(), kCharsetLatin1, realm)) {
       return false;
     }
   }
   return parameters.valid();
 }
 
 }  // namespace
 
 int HttpAuthHandlerBasic::Init(const HttpAuthChallengeTokenizer& challenge) {
-  auth_scheme_ = kBasicSchemeName;
   return ParseChallenge(challenge);
 }
 
+HttpAuthHandlerBasic::HttpAuthHandlerBasic()
+    : HttpAuthHandler(kBasicSchemeName) {}
+
 int HttpAuthHandlerBasic::ParseChallenge(
     const HttpAuthChallengeTokenizer& challenge) {
   // Verify the challenge's auth-scheme.
   if (!challenge.SchemeIs(kBasicSchemeName))
     return ERR_INVALID_RESPONSE;
 
   std::string realm;
   if (!ParseRealm(challenge, &realm))
     return ERR_INVALID_RESPONSE;
 
@@ skipping 28 matching lines @@
   *auth_token = "Basic " + base64_username_password;
   return OK;
 }
 
 HttpAuthHandlerBasic::Factory::Factory() {
 }
 
 HttpAuthHandlerBasic::Factory::~Factory() {
 }
 
-int HttpAuthHandlerBasic::Factory::CreateAuthHandler(
-    const HttpAuthChallengeTokenizer& challenge,
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerBasic::Factory::CreateAuthHandlerForScheme(
+    const std::string& scheme) {
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
+  if (scheme == kBasicSchemeName)
+    return make_scoped_ptr(new HttpAuthHandlerBasic());
+  return scoped_ptr<HttpAuthHandler>();
+}
+
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerBasic::Factory::CreateAndInitPreemptiveAuthHandler(
+    HttpAuthCache::Entry* cache_entry,
+    const HttpAuthChallengeTokenizer& tokenizer,
     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 HttpAuthHandlerBasic());
-  int result =
-      tmp_handler->HandleInitialChallenge(challenge, target, origin, net_log);
-  if (result == OK)
-    handler->swap(tmp_handler);
-  return result;
+    const BoundNetLog& net_log) {
+  if (cache_entry->scheme() != kBasicSchemeName)
+    return scoped_ptr<HttpAuthHandler>();
+  scoped_ptr<HttpAuthHandler> handler(new HttpAuthHandlerBasic());
+  int rv = handler->HandleInitialChallenge(tokenizer, target,
+                                           cache_entry->origin(), net_log);
+  if (rv == OK)
+    return handler;
+  return scoped_ptr<HttpAuthHandler>();
 }
 
 }  // namespace net