[net/http auth] Generalize HttpAuthHandlerMock.

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 44 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://example.com");
 
   scoped_refptr<HttpResponseHeaders> headers(HeadersFromString(
       "HTTP/1.1 407\r\n"
       "Proxy-Authenticate: MOCK foo\r\n"
       "\r\n"));
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
-  HttpAuthHandlerMock* auth_handler = new HttpAuthHandlerMock();
+  scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
   auth_handler->SetGenerateExpectation((run_mode == RUN_HANDLER_ASYNC),
                                        handler_rv);
-  auth_handler_factory.AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
-  auth_handler_factory.set_do_init_from_challenge(true);
+  auth_handler_factory.AddMockHandler(auth_handler.Pass(),
+                                      HttpAuthHandlerFactory::CREATE_CHALLENGE,
+                                      HttpAuth::AUTH_PROXY);
 
   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());
+  controller->ResetAuth(
+      AuthCredentials(base::ASCIIToUTF16("a"), base::ASCIIToUTF16("b")));
   EXPECT_TRUE(controller->HaveAuth());
 
   TestCompletionCallback callback;
   EXPECT_EQ((run_mode == RUN_HANDLER_ASYNC)? ERR_IO_PENDING:
             expected_controller_rv,
             controller->MaybeGenerateAuthToken(&request, callback.callback(),
                                                dummy_log));
   if (run_mode == RUN_HANDLER_ASYNC)
     EXPECT_EQ(expected_controller_rv, callback.WaitForResult());
   EXPECT_EQ((scheme_state == SCHEME_IS_DISABLED),
@@ skipping 23 matching lines @@
 
   // If a non-permanent error is returned by the handler, then the
   // controller should report it unchanged.
   RunSingleRoundAuthTest(RUN_HANDLER_ASYNC, ERR_INVALID_AUTH_CREDENTIALS,
                          ERR_INVALID_AUTH_CREDENTIALS, SCHEME_IS_ENABLED);
 }
 
 // If an HttpAuthHandler indicates that it doesn't allow explicit
 // credentials, don't prompt for credentials.
 TEST(HttpAuthControllerTest, NoExplicitCredentialsAllowed) {
-  // Modified mock HttpAuthHandler for this test.
-  class MockHandler : public HttpAuthHandlerMock {
-   public:
-    MockHandler(int expected_rv, const std::string& scheme)
-        : expected_scheme_(scheme) {
-      SetGenerateExpectation(false, expected_rv);
-    }
-
-   protected:
-    bool Init(HttpAuthChallengeTokenizer* challenge) override {
-      HttpAuthHandlerMock::Init(challenge);
-      set_allows_default_credentials(true);
-      set_allows_explicit_credentials(false);
-      // Pretend to be Bert so we can test failover logic.
-      if (challenge->SchemeIs("bert")) {
-        auth_scheme_ = "bert";
-        set_allows_explicit_credentials(true);
-      } else {
-        auth_scheme_ = "ernie";
-      }
-      EXPECT_EQ(expected_scheme_, auth_scheme_);
-      return true;
-    }
-
-    int GenerateAuthTokenImpl(const AuthCredentials* credentials,
-                              const HttpRequestInfo* request,
-                              const CompletionCallback& callback,
-                              std::string* auth_token) override {
-      int result =
-          HttpAuthHandlerMock::GenerateAuthTokenImpl(credentials,
-                                                     request, callback,
-                                                     auth_token);
-      EXPECT_TRUE(result != OK ||
-                  !AllowsExplicitCredentials() ||
-                  !credentials->Empty());
-      return result;
-    }
-
-   private:
-    std::string expected_scheme_;
-  };
-
   BoundNetLog dummy_log;
   HttpAuthCache dummy_auth_cache;
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://example.com");
 
   HttpRequestHeaders request_headers;
   scoped_refptr<HttpResponseHeaders> headers(
       HeadersFromString("HTTP/1.1 401\r\n"
                         "WWW-Authenticate: Ernie\r\n"
                         "WWW-Authenticate: Bert\r\n"
                         "\r\n"));
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
-  auth_handler_factory.set_do_init_from_challenge(true);
 
   // Handler for the first attempt at authentication. "Ernie" handler accepts
-  // the default identity and successfully constructs a token.
-  auth_handler_factory.AddMockHandler(new MockHandler(OK, "ernie"),
+  // 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);
 
   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));
 
   // 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_factory.AddMockHandler(new MockHandler(ERR_UNEXPECTED, "ernie"),
+  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);
 
   // 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_factory.AddMockHandler(new MockHandler(OK, "bert"),
+  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);
 
   // 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