[net/http auth] Split HttpAuthHandler creation from initialization.

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/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_cache.h"
@@ skipping 48 matching lines @@
   scoped_refptr<HttpResponseHeaders> headers(HeadersFromString(
       "HTTP/1.1 407\r\n"
       "Proxy-Authenticate: MOCK foo\r\n"
       "\r\n"));
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
   scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
   auth_handler->SetGenerateExpectation((run_mode == RUN_HANDLER_ASYNC),
                                        handler_rv);
   auth_handler_factory.AddMockHandler(auth_handler.Pass(),
-                                      HttpAuthHandlerFactory::CREATE_CHALLENGE,
-                                      HttpAuth::AUTH_PROXY);
+                                      HttpAuthHandlerCreateReason::CHALLENGE);
 
   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(
       AuthCredentials(base::ASCIIToUTF16("a"), base::ASCIIToUTF16("b")));
@@ skipping 55 matching lines @@
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
 
   // Handler for the first attempt at authentication. "Ernie" handler accepts
   // the default identity and successfully constructs a token.  Handler for the
   scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
   auth_handler->set_allows_default_credentials(true);
   auth_handler->set_allows_explicit_credentials(false);
   auth_handler->set_expected_auth_scheme("ernie");
   auth_handler_factory.AddMockHandler(auth_handler.Pass(),
-                                      HttpAuthHandlerFactory::CREATE_CHALLENGE,
-                                      HttpAuth::AUTH_SERVER);
+                                      HttpAuthHandlerCreateReason::CHALLENGE);
 
   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(AuthCredentials());
   EXPECT_TRUE(controller->HaveAuth());
-  EXPECT_FALSE(auth_handler_factory.HaveAuthHandlers(HttpAuth::AUTH_SERVER));
+  EXPECT_FALSE(auth_handler_factory.HaveAuthHandlers());
 
   // Should only succeed if we are using the "Ernie" MockHandler.
   EXPECT_EQ(OK, controller->MaybeGenerateAuthToken(
       &request, CompletionCallback(), dummy_log));
   controller->AddAuthorizationHeader(&request_headers);
 
   // Handlers for the second attempt. Neither should be used to generate a
   // token. Instead the controller should realize that there are no viable
   // identities to use with the "Ernie" handler and fail.
   auth_handler.reset(new HttpAuthHandlerMock());
   auth_handler->set_allows_default_credentials(true);
   auth_handler->set_allows_explicit_credentials(false);
   auth_handler->set_expected_auth_scheme("ernie");
   auth_handler_factory.AddMockHandler(auth_handler.Pass(),
-                                      HttpAuthHandlerFactory::CREATE_CHALLENGE,
-                                      HttpAuth::AUTH_SERVER);
+                                      HttpAuthHandlerCreateReason::CHALLENGE);
 
   // Fallback handlers for the second attempt. The "Ernie" handler should be
   // discarded due to the disabled scheme, and the "Bert" handler should
   // successfully be used to generate a token.
   auth_handler.reset(new HttpAuthHandlerMock());
   auth_handler->set_allows_default_credentials(false);
   auth_handler->set_allows_explicit_credentials(true);
   auth_handler->set_expected_auth_scheme("bert");
   auth_handler_factory.AddMockHandler(auth_handler.Pass(),
-                                      HttpAuthHandlerFactory::CREATE_CHALLENGE,
-                                      HttpAuth::AUTH_SERVER);
+                                      HttpAuthHandlerCreateReason::CHALLENGE);
 
   // 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(AuthCredentials(base::ASCIIToUTF16("Hello"),
                         base::string16()));
   EXPECT_TRUE(controller->HaveAuth());
   EXPECT_TRUE(controller->IsAuthSchemeDisabled("ernie"));
   EXPECT_FALSE(controller->IsAuthSchemeDisabled("bert"));
 
   // Should only succeed if we are using the "Bert" MockHandler.
   EXPECT_EQ(OK, controller->MaybeGenerateAuthToken(
       &request, CompletionCallback(), dummy_log));
 }
 
 }  // namespace net