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

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"
@@ skipping 10 matching lines @@
 
 HttpAuthHandlerMock::~HttpAuthHandlerMock() {
 }
 
 void HttpAuthHandlerMock::SetGenerateExpectation(bool async, int rv) {
   generate_async_ = async;
   generate_rv_ = rv;
 }
 
 HttpAuth::AuthorizationResult HttpAuthHandlerMock::HandleAnotherChallenge(
-    HttpAuthChallengeTokenizer* challenge) {
+    const HttpAuthChallengeTokenizer& challenge) {
   // 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())
+  if (!expect_multiple_challenges_ || challenge.base64_param().empty())
     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
-  if (!challenge->SchemeIs(auth_scheme_))
+  if (!challenge.SchemeIs(auth_scheme_))
     return HttpAuth::AUTHORIZATION_RESULT_INVALID;
   auth_token_ = auth_scheme_;
   auth_token_.append(" continuation,");
-  auth_token_.append(challenge->base64_param());
+  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_;
 }
 
-bool HttpAuthHandlerMock::Init(HttpAuthChallengeTokenizer* challenge) {
-  EXPECT_TRUE(challenge->SchemeIs(expected_auth_scheme_))
-      << "Mismatched scheme for challenge: " << challenge->challenge_text();
+int HttpAuthHandlerMock::Init(const HttpAuthChallengeTokenizer& challenge) {
+  EXPECT_TRUE(challenge.SchemeIs(expected_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_))
       << "Invalid expected auth scheme.";
   auth_scheme_ = expected_auth_scheme_;
   auth_token_ = expected_auth_scheme_ + " auth_token";
-  if (challenge->params_end() != challenge->params_begin()) {
+  if (challenge.params_end() != challenge.params_begin()) {
     auth_token_ += ",";
-    auth_token_.append(challenge->params_begin(), challenge->params_end());
+    auth_token_.append(challenge.params_begin(), challenge.params_end());
   }
-  return true;
+  return OK;
 }
 
 int HttpAuthHandlerMock::GenerateAuthTokenImpl(
     const AuthCredentials* credentials,
-    const HttpRequestInfo* request,
+    const HttpRequestInfo& request,
     const CompletionCallback& callback,
     std::string* auth_token) {
   first_round_ = false;
-  request_url_ = request->url;
+  request_url_ = request.url;
 
   if (!credentials || credentials->Empty()) {
     EXPECT_TRUE(AllowsDefaultCredentials()) << "Credentials must be specified "
                                                "if the handler doesn't support "
                                                "default credentials.";
   } else {
     EXPECT_TRUE(AllowsExplicitCredentials()) << "Explicit credentials can only "
                                                 "be specified if the handler "
                                                 "supports it.";
   }
@@ skipping 42 matching lines @@
     challenge_handlers_[target].push_back(handler.Pass());
 }
 
 bool HttpAuthHandlerMock::Factory::HaveAuthHandlers(
     HttpAuth::Target target) const {
   return !challenge_handlers_[target].empty() ||
          !preemptive_handlers_[target].empty();
 }
 
 int HttpAuthHandlerMock::Factory::CreateAuthHandler(
-    HttpAuthChallengeTokenizer* challenge,
+    const HttpAuthChallengeTokenizer& challenge,
     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());
-  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;
 }
 
 }  // namespace net