Change HttpAuthHandlerMock to accept and return more than one

net/http/http_network_transaction_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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 7415 matching lines @@
                   &kGet, &kServerChallenge),
         TestRound(kGetAuth, kSuccess, OK)}},
     { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 3, 1,
       { TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kProxyConnected, OK,
                   &kGet, &kServerChallenge),
         TestRound(kGetAuth, kFailure, kAuthErr)}},
   };
 
   SessionDependencies session_deps;
-  HttpAuthHandlerMock::Factory* auth_factory(
-      new HttpAuthHandlerMock::Factory());
-  session_deps.http_auth_handler_factory.reset(auth_factory);
-
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_configs); ++i) {
+    HttpAuthHandlerMock::Factory* auth_factory(
+        new HttpAuthHandlerMock::Factory());
+    session_deps.http_auth_handler_factory.reset(auth_factory);
     const TestConfig& test_config = test_configs[i];
 
     // Set up authentication handlers as necessary.
     if (test_config.proxy_auth_timing != AUTH_NONE) {
-      HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
-      std::string auth_challenge = "Mock realm=proxy";
-      GURL origin(test_config.proxy_url);
-      HttpAuth::ChallengeTokenizer tokenizer(auth_challenge.begin(),
-                                             auth_challenge.end());
-      auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_PROXY,
-                                      origin, BoundNetLog());
-      auth_handler->SetGenerateExpectation(
-          test_config.proxy_auth_timing == AUTH_ASYNC,
-          test_config.proxy_auth_rv);
-      auth_factory->set_mock_handler(auth_handler, HttpAuth::AUTH_PROXY);
+      for (int n = 0; n < 2; n++) {
+        HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
+        std::string auth_challenge = "Mock realm=proxy";
+        GURL origin(test_config.proxy_url);
+        HttpAuth::ChallengeTokenizer tokenizer(auth_challenge.begin(),
+                                               auth_challenge.end());
+        auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_PROXY,
+                                        origin, BoundNetLog());
+        auth_handler->SetGenerateExpectation(
+            test_config.proxy_auth_timing == AUTH_ASYNC,
+            test_config.proxy_auth_rv);
+        auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
+      }
     }
     if (test_config.server_auth_timing != AUTH_NONE) {
       HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
       std::string auth_challenge = "Mock realm=server";
       GURL origin(test_config.server_url);
       HttpAuth::ChallengeTokenizer tokenizer(auth_challenge.begin(),
                                              auth_challenge.end());
       auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
                                       origin, BoundNetLog());
       auth_handler->SetGenerateExpectation(
           test_config.server_auth_timing == AUTH_ASYNC,
           test_config.server_auth_rv);
-      auth_factory->set_mock_handler(auth_handler, HttpAuth::AUTH_SERVER);
+      auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
     }
     if (test_config.proxy_url) {
       session_deps.proxy_service.reset(
           ProxyService::CreateFixed(test_config.proxy_url));
     } else {
       session_deps.proxy_service.reset(ProxyService::CreateDirect());
     }
 
     HttpRequestInfo request;
     request.method = "GET";
@@ skipping 73 matching lines @@
   session_deps.host_resolver->set_synchronous_mode(true);
 
   HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
   auth_handler->set_connection_based(true);
   std::string auth_challenge = "Mock realm=server";
   GURL origin("http://www.example.com");
   HttpAuth::ChallengeTokenizer tokenizer(auth_challenge.begin(),
                                          auth_challenge.end());
   auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
                                   origin, BoundNetLog());
-  auth_factory->set_mock_handler(auth_handler, HttpAuth::AUTH_SERVER);
+  auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
 
   int rv = OK;
   const HttpResponseInfo* response = NULL;
   HttpRequestInfo request;
   request.method = "GET";
   request.url = origin;
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
@@ skipping 373 matching lines @@
   // This test ensures that the URL passed into the proxy is upgraded
   // to https when doing an Alternate Protocol upgrade.
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::set_next_protos(
       "\x08http/1.1\x07http1.1\x06spdy/2\x04spdy");
 
   SessionDependencies session_deps(ProxyService::CreateFixed("myproxy:70"));
   HttpAuthHandlerMock::Factory* auth_factory =
       new HttpAuthHandlerMock::Factory();
   HttpAuthHandlerMock* auth_handler = new HttpAuthHandlerMock();
-  auth_factory->set_mock_handler(auth_handler, HttpAuth::AUTH_PROXY);
+  auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
   auth_factory->set_do_init_from_challenge(true);
   session_deps.http_auth_handler_factory.reset(auth_factory);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com");
   request.load_flags = 0;
 
   // First round goes unauthenticated through the proxy.
   MockWrite data_writes_1[] = {
@@ skipping 1031 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
   HttpStreamFactory::set_next_protos("");
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 }  // namespace net