Use AuthCredentials throughout the network stack instead of username/password.

net/http/http_auth_controller_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 "net/http/http_auth_controller.h"
 
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 56 matching lines @@
   auth_handler_factory.AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
   auth_handler_factory.set_do_init_from_challenge(true);
 
   scoped_refptr<HttpAuthController> controller(
       new HttpAuthController(HttpAuth::AUTH_PROXY,
                              GURL("http://example.com"),
                              &dummy_auth_cache, &auth_handler_factory));
   ASSERT_EQ(OK,
             controller->HandleAuthChallenge(headers, false, false, dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
-  controller->ResetAuth(string16(), string16());
+  controller->ResetAuth(AuthCredentials());
   EXPECT_TRUE(controller->HaveAuth());
 
   TestOldCompletionCallback callback;
   EXPECT_EQ((run_mode == RUN_HANDLER_ASYNC)? ERR_IO_PENDING:
             expected_controller_rv,
             controller->MaybeGenerateAuthToken(&request, &callback,
                                                dummy_log));
   if (run_mode == RUN_HANDLER_ASYNC)
     EXPECT_EQ(expected_controller_rv, callback.WaitForResult());
   EXPECT_EQ((scheme_state == SCHEME_IS_DISABLED),
@@ skipping 47 matching lines @@
       // Pretend to be SCHEME_BASIC so we can test failover logic.
       if (challenge->scheme() == "Basic") {
         auth_scheme_ = HttpAuth::AUTH_SCHEME_BASIC;
         --score_;  // Reduce score, so we rank below Mock.
         set_allows_explicit_credentials(true);
       }
       EXPECT_EQ(expected_scheme_, auth_scheme_);
       return true;
     }
 
-    virtual int GenerateAuthTokenImpl(const string16* username,
-                                      const string16* password,
+    virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                       const HttpRequestInfo* request,
                                       OldCompletionCallback* callback,
                                       std::string* auth_token) OVERRIDE {
       int result =
-          HttpAuthHandlerMock::GenerateAuthTokenImpl(username, password,
+          HttpAuthHandlerMock::GenerateAuthTokenImpl(credentials,
                                                      request, callback,
                                                      auth_token);
       EXPECT_TRUE(result != OK ||
-                  !AllowsExplicitCredentials() || !username->empty());
+                  !AllowsExplicitCredentials() ||
+                  !credentials->Empty());
       return result;
     }
 
    private:
     HttpAuth::Scheme expected_scheme_;
   };
 
   BoundNetLog dummy_log;
   HttpAuthCache dummy_auth_cache;
   HttpRequestInfo request;
@@ skipping 38 matching lines @@
       HttpAuth::AUTH_SERVER);
   auth_handler_factory.set_do_init_from_challenge(true);
 
   scoped_refptr<HttpAuthController> controller(
       new HttpAuthController(HttpAuth::AUTH_SERVER,
                              GURL("http://example.com"),
                              &dummy_auth_cache, &auth_handler_factory));
   ASSERT_EQ(OK,
             controller->HandleAuthChallenge(headers, false, false, dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
-  controller->ResetAuth(string16(), string16());
+  controller->ResetAuth(AuthCredentials());
   EXPECT_TRUE(controller->HaveAuth());
 
   // Should only succeed if we are using the AUTH_SCHEME_MOCK MockHandler.
   EXPECT_EQ(OK, controller->MaybeGenerateAuthToken(&request, NULL, dummy_log));
   controller->AddAuthorizationHeader(&request_headers);
 
   // Once a token is generated, simulate the receipt of a server response
   // indicating that the authentication attempt was rejected.
   ASSERT_EQ(OK,
             controller->HandleAuthChallenge(headers, false, false, dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
-  controller->ResetAuth(ASCIIToUTF16("Hello"), string16());
+  controller->ResetAuth(AuthCredentials(ASCIIToUTF16("Hello"), string16()));
   EXPECT_TRUE(controller->HaveAuth());
   EXPECT_TRUE(controller->IsAuthSchemeDisabled(HttpAuth::AUTH_SCHEME_MOCK));
   EXPECT_FALSE(controller->IsAuthSchemeDisabled(HttpAuth::AUTH_SCHEME_BASIC));
 
   // Should only succeed if we are using the AUTH_SCHEME_BASIC MockHandler.
   EXPECT_EQ(OK, controller->MaybeGenerateAuthToken(&request, NULL, dummy_log));
 }
 
 }  // namespace net