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

net/http/http_auth.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.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 91 matching lines @@
     int cur_priority = GetSchemePriority(cur_auth_scheme);
     if (best.get() && best_priority >= cur_priority)
       continue;
 
     // Immediately trying to create a handler may be wasteful because we may see
     // a higher ranking challenge later on in the headers. However, this is
     // rare. Servers typically specify higher priority schemes before lower
     // priority schemes.
     scoped_ptr<HttpAuthHandler> current_handler;
     int rv = http_auth_handler_factory->CreateAuthHandler(
-        &challenge_tokenizer, target, origin,
+        challenge_tokenizer, target, origin,
         HttpAuthHandlerFactory::CREATE_CHALLENGE, 1, net_log, &current_handler);
     if (rv != OK) {
       net_log.AddEvent(
           NetLog::TYPE_AUTH_HANDLER_CREATION_FAILURE,
           base::Bind(&AuthHandlerCreationFailureParams, &cur_challenge, rv));
       continue;
     }
     DCHECK(current_handler.get());
     DCHECK_EQ(cur_auth_scheme, current_handler->auth_scheme());
     best.swap(current_handler);
@@ skipping 18 matching lines @@
     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
   const std::string header_name = GetChallengeHeaderName(target);
   void* iter = NULL;
   std::string challenge;
   HttpAuth::AuthorizationResult authorization_result =
       HttpAuth::AUTHORIZATION_RESULT_INVALID;
   while (headers->EnumerateHeader(&iter, header_name, &challenge)) {
     HttpAuthChallengeTokenizer props(challenge.begin(), challenge.end());
     if (!props.SchemeIs(current_scheme))
       continue;
-    authorization_result = handler->HandleAnotherChallenge(&props);
+    authorization_result = handler->HandleAnotherChallenge(props);
     if (authorization_result != HttpAuth::AUTHORIZATION_RESULT_INVALID) {
       *challenge_used = challenge;
       return authorization_result;
     }
   }
   // Finding no matches is equivalent to rejection.
   return HttpAuth::AUTHORIZATION_RESULT_REJECT;
 }
 
 // static
@@ skipping 35 matching lines @@
   }
 }
 
 // static
 bool HttpAuth::IsValidNormalizedScheme(const std::string& scheme) {
   return HttpUtil::IsToken(scheme.begin(), scheme.end()) &&
          base::ToLowerASCII(scheme) == scheme;
 }
 
 }  // namespace net