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

net/http/http_auth_handler_ntlm.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_ntlm.h"
 
 #if !defined(NTLM_SSPI)
 #include "base/base64.h"
 #endif
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 
 namespace net {
 
 HttpAuth::AuthorizationResult HttpAuthHandlerNTLM::HandleAnotherChallenge(
-    HttpAuthChallengeTokenizer* challenge) {
+    const HttpAuthChallengeTokenizer& challenge) {
   return ParseChallenge(challenge, false);
 }
 
-bool HttpAuthHandlerNTLM::Init(HttpAuthChallengeTokenizer* tok) {
+int HttpAuthHandlerNTLM::Init(const HttpAuthChallengeTokenizer& tok) {
   auth_scheme_ = "ntlm";
-  return ParseChallenge(tok, true) == HttpAuth::AUTHORIZATION_RESULT_ACCEPT;
+  return ParseChallenge(tok, true) == HttpAuth::AUTHORIZATION_RESULT_ACCEPT
+             ? OK
+             : ERR_INVALID_RESPONSE;
 }
 
 int HttpAuthHandlerNTLM::GenerateAuthTokenImpl(
-    const AuthCredentials* credentials, const HttpRequestInfo* request,
-    const CompletionCallback& callback, std::string* auth_token) {
+    const AuthCredentials* credentials,
+    const HttpRequestInfo& request,
+    const CompletionCallback& callback,
+    std::string* auth_token) {
 #if defined(NTLM_SSPI)
   return auth_sspi_.GenerateAuthToken(credentials, CreateSPN(origin_),
                                       auth_token, callback);
 #else  // !defined(NTLM_SSPI)
   // TODO(cbentzel): Shouldn't be hitting this case.
   if (!credentials) {
     LOG(ERROR) << "Username and password are expected to be non-NULL.";
     return ERR_MISSING_AUTH_CREDENTIALS;
   }
   // TODO(wtc): See if we can use char* instead of void* for in_buf and
@@ skipping 47 matching lines @@
   // OK, we are done with |out_buf|
   free(out_buf);
   *auth_token = std::string("NTLM ") + encode_output;
   return OK;
 #endif
 }
 
 // The NTLM challenge header looks like:
 //   WWW-Authenticate: NTLM auth-data
 HttpAuth::AuthorizationResult HttpAuthHandlerNTLM::ParseChallenge(
-    HttpAuthChallengeTokenizer* tok, bool initial_challenge) {
+    const HttpAuthChallengeTokenizer& tok,
+    bool initial_challenge) {
 #if defined(NTLM_SSPI)
   // auth_sspi_ contains state for whether or not this is the initial challenge.
   return auth_sspi_.ParseChallenge(tok);
 #else
   // TODO(cbentzel): Most of the logic between SSPI, GSSAPI, and portable NTLM
   // authentication parsing could probably be shared - just need to know if
   // there was previously a challenge round.
   // TODO(cbentzel): Write a test case to validate that auth_data_ is left empty
   // in all failure conditions.
   auth_data_.clear();
 
   // Verify the challenge's auth-scheme.
-  if (!tok->SchemeIs("ntlm"))
+  if (!tok.SchemeIs("ntlm"))
     return HttpAuth::AUTHORIZATION_RESULT_INVALID;
 
-  std::string base64_param = tok->base64_param();
+  std::string base64_param = tok.base64_param();
   if (base64_param.empty()) {
     if (!initial_challenge)
       return HttpAuth::AUTHORIZATION_RESULT_REJECT;
     return HttpAuth::AUTHORIZATION_RESULT_ACCEPT;
   } else {
     if (initial_challenge)
       return HttpAuth::AUTHORIZATION_RESULT_INVALID;
   }
 
   auth_data_ = base64_param;
   return HttpAuth::AUTHORIZATION_RESULT_ACCEPT;
 #endif  // defined(NTLM_SSPI)
 }
 
 // static
 std::string HttpAuthHandlerNTLM::CreateSPN(const GURL& origin) {
   // The service principal name of the destination server.  See
   // http://msdn.microsoft.com/en-us/library/ms677949%28VS.85%29.aspx
   std::string target("HTTP/");
   target.append(GetHostAndPort(origin));
   return target;
 }
 
 }  // namespace net