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

net/http/http_auth_handler_digest_unittest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
@@ skipping 52 matching lines @@
 
   // Create a token in response to the challenge.
   // NOTE: HttpAuthHandlerDigest's implementation of GenerateAuthToken always
   // completes synchronously. That's why this test can get away with a
   // TestCompletionCallback without an IO thread.
   TestCompletionCallback callback;
   scoped_ptr<HttpRequestInfo> request(new HttpRequestInfo());
   request->url = GURL(request_url);
   AuthCredentials credentials(base::ASCIIToUTF16("foo"),
                               base::ASCIIToUTF16("bar"));
-  int rv_generate = handler->GenerateAuthToken(
-      &credentials, request.get(), callback.callback(), token);
+  int rv_generate = handler->GenerateAuthToken(&credentials, *request,
+                                               callback.callback(), token);
   if (rv_generate != OK) {
     ADD_FAILURE() << "Problems generating auth token";
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
@@ skipping 462 matching lines @@
       "Digest realm=\"Oblivion\", nonce=\"nonce-value\"";
   GURL origin("intranet.google.com");
   int rv = factory->CreateAuthHandlerFromString(
       default_challenge, HttpAuth::AUTH_SERVER, origin, BoundNetLog(),
       &handler);
   EXPECT_EQ(OK, rv);
   ASSERT_TRUE(handler.get() != NULL);
   HttpAuthChallengeTokenizer tok_default(default_challenge.begin(),
                                          default_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_REJECT,
-            handler->HandleAnotherChallenge(&tok_default));
+            handler->HandleAnotherChallenge(tok_default));
 
   std::string stale_challenge = default_challenge + ", stale=true";
   HttpAuthChallengeTokenizer tok_stale(stale_challenge.begin(),
                                        stale_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_STALE,
-            handler->HandleAnotherChallenge(&tok_stale));
+            handler->HandleAnotherChallenge(tok_stale));
 
   std::string stale_false_challenge = default_challenge + ", stale=false";
   HttpAuthChallengeTokenizer tok_stale_false(stale_false_challenge.begin(),
                                              stale_false_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_REJECT,
-            handler->HandleAnotherChallenge(&tok_stale_false));
+            handler->HandleAnotherChallenge(tok_stale_false));
 
   std::string realm_change_challenge =
       "Digest realm=\"SomethingElse\", nonce=\"nonce-value2\"";
   HttpAuthChallengeTokenizer tok_realm_change(realm_change_challenge.begin(),
                                               realm_change_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM,
-            handler->HandleAnotherChallenge(&tok_realm_change));
+            handler->HandleAnotherChallenge(tok_realm_change));
 }
 
 TEST(HttpAuthHandlerDigest, RespondToServerChallenge) {
   std::string auth_token;
   EXPECT_TRUE(RespondToChallenge(
       HttpAuth::AUTH_SERVER,
       std::string(),
       "http://www.example.com/path/to/resource",
       kSimpleChallenge,
       &auth_token));
@@ skipping 100 matching lines @@
   EXPECT_EQ("Digest username=\"foo\", realm=\"Oblivion\", "
             "nonce=\"nonce-value\", uri=\"/path/to/resource\", "
             "response=\"5b1459beda5cee30d6ff9e970a69c0ea\", "
             "opaque=\"opaque text\", "
             "qop=auth, nc=00000001, cnonce=\"client_nonce\"",
             auth_token);
 }
 
 
 } // namespace net