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

net/http/http_auth_handler_mock.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_mock.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_request_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 HttpAuthHandlerMock::HttpAuthHandlerMock()
-    : expected_auth_scheme_("mock"), weak_factory_(this) {}
+    : HttpAuthHandler("mock"), weak_factory_(this) {}
 
-HttpAuthHandlerMock::~HttpAuthHandlerMock() {
-}
+HttpAuthHandlerMock::~HttpAuthHandlerMock() {}
 
 void HttpAuthHandlerMock::SetGenerateExpectation(bool async, int rv) {
   generate_async_ = async;
   generate_rv_ = rv;
 }
 
 HttpAuth::AuthorizationResult HttpAuthHandlerMock::HandleAnotherChallenge(
     const HttpAuthChallengeTokenizer& challenge) {
+  EXPECT_TRUE(challenge.SchemeIs(auth_scheme_));
   // If we receive a second challenge for a regular scheme, assume it's a
   // rejection. Receiving an empty second challenge when expecting multiple
   // rounds is also considered a rejection.
   if (!expect_multiple_challenges_ || challenge.base64_param().empty())
     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
   if (!challenge.SchemeIs(auth_scheme_))
     return HttpAuth::AUTHORIZATION_RESULT_INVALID;
   auth_token_ = auth_scheme_;
   auth_token_.append(" continuation,");
   auth_token_.append(challenge.base64_param());
   return HttpAuth::AUTHORIZATION_RESULT_ACCEPT;
 }
 
 bool HttpAuthHandlerMock::NeedsIdentity() {
   return first_round_;
 }
 
 bool HttpAuthHandlerMock::AllowsDefaultCredentials() {
   return allows_default_credentials_;
 }
 
 bool HttpAuthHandlerMock::AllowsExplicitCredentials() {
   return allows_explicit_credentials_;
 }
 
 int HttpAuthHandlerMock::Init(const HttpAuthChallengeTokenizer& challenge) {
-  EXPECT_TRUE(challenge.SchemeIs(expected_auth_scheme_))
+  EXPECT_TRUE(challenge.SchemeIs(auth_scheme_))
       << "Mismatched scheme for challenge: " << challenge.challenge_text();
-  EXPECT_TRUE(auth_scheme_.empty()) << "Init was already called.";
-  EXPECT_TRUE(HttpAuth::IsValidNormalizedScheme(expected_auth_scheme_))
+  EXPECT_TRUE(HttpAuth::IsValidNormalizedScheme(auth_scheme_))
       << "Invalid expected auth scheme.";
-  auth_scheme_ = expected_auth_scheme_;
-  auth_token_ = expected_auth_scheme_ + " auth_token";
+  auth_token_ = auth_scheme_ + " auth_token";
   if (challenge.params_end() != challenge.params_begin()) {
     auth_token_ += ",";
     auth_token_.append(challenge.params_begin(), challenge.params_end());
   }
   return OK;
 }
 
 int HttpAuthHandlerMock::GenerateAuthTokenImpl(
     const AuthCredentials* credentials,
     const HttpRequestInfo& request,
@@ skipping 41 matching lines @@
   callback.Run(generate_rv_);
 }
 
 HttpAuthHandlerMock::Factory::Factory() {}
 
 HttpAuthHandlerMock::Factory::~Factory() {
 }
 
 void HttpAuthHandlerMock::Factory::AddMockHandler(
     scoped_ptr<HttpAuthHandler> handler,
-    CreateReason reason,
-    HttpAuth::Target target) {
-  if (reason == CREATE_PREEMPTIVE)
-    preemptive_handlers_[target].push_back(handler.Pass());
+    HttpAuthHandlerCreateReason reason) {
+  if (reason == HttpAuthHandlerCreateReason::PREEMPTIVE)
+    preemptive_handlers_.push_back(handler.Pass());
   else
-    challenge_handlers_[target].push_back(handler.Pass());
+    challenge_handlers_.push_back(handler.Pass());
 }
 
-bool HttpAuthHandlerMock::Factory::HaveAuthHandlers(
-    HttpAuth::Target target) const {
-  return !challenge_handlers_[target].empty() ||
-         !preemptive_handlers_[target].empty();
+bool HttpAuthHandlerMock::Factory::HaveAuthHandlers() const {
+  return !challenge_handlers_.empty() || !preemptive_handlers_.empty();
 }
 
-int HttpAuthHandlerMock::Factory::CreateAuthHandler(
-    const HttpAuthChallengeTokenizer& challenge,
+scoped_ptr<HttpAuthHandler> HttpAuthHandlerMock::Factory::GetNextAuthHandler(
+    ScopedVector<HttpAuthHandler>* handler_list) {
+  if (handler_list->empty())
+    return scoped_ptr<HttpAuthHandler>();
+  scoped_ptr<HttpAuthHandler> tmp_handler(handler_list->front());
+  handler_list->weak_erase(handler_list->begin());
+  return tmp_handler;
+}
+
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerMock::Factory::CreateAuthHandlerForScheme(
+    const std::string& scheme) {
+  scoped_ptr<HttpAuthHandler> handler =
+      GetNextAuthHandler(&challenge_handlers_);
+  EXPECT_TRUE(!handler || handler->auth_scheme() == scheme)
+      << "Next auth handler is for scheme " << handler->auth_scheme()
+      << " while request scheme is " << scheme;
+  return handler.Pass();
+}
+
+scoped_ptr<HttpAuthHandler>
+HttpAuthHandlerMock::Factory::CreateAndInitPreemptiveAuthHandler(
+    HttpAuthCache::Entry* cache_entry,
+    const HttpAuthChallengeTokenizer& tokenizer,
     HttpAuth::Target target,
-    const GURL& origin,
-    CreateReason reason,
-    int nonce_count,
-    const BoundNetLog& net_log,
-    scoped_ptr<HttpAuthHandler>* handler) {
-  ScopedVector<HttpAuthHandler>& handler_list =
-      reason == CREATE_PREEMPTIVE ? preemptive_handlers_[target]
-                                  : challenge_handlers_[target];
-  if (handler_list.empty())
-    return ERR_UNEXPECTED;
-  scoped_ptr<HttpAuthHandler> tmp_handler(handler_list.front());
-  handler_list.weak_erase(handler_list.begin());
-  int result =
-      tmp_handler->HandleInitialChallenge(challenge, target, origin, net_log);
-  if (result == OK)
-    handler->swap(tmp_handler);
-  return result;
+    const BoundNetLog& net_log) {
+  scoped_ptr<HttpAuthHandler> handler =
+      GetNextAuthHandler(&preemptive_handlers_);
+  if (handler) {
+    handler->HandleInitialChallenge(tokenizer, target, cache_entry->origin(),
+                                    net_log);
+  }
+  return handler;
 }
 
 }  // namespace net