Support tls-server-end-point channel bindings for HTTP authentication.

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"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_handler_mock.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 enum HandlerRunMode {
   RUN_HANDLER_SYNC,
@@ skipping 24 matching lines @@
                             int handler_rv,
                             int expected_controller_rv,
                             SchemeState scheme_state) {
   BoundNetLog dummy_log;
   HttpAuthCache dummy_auth_cache;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://example.com");
 
-  scoped_refptr<HttpResponseHeaders> headers(HeadersFromString(
+  HttpResponseInfo response_info;
+  response_info.headers = HeadersFromString(
       "HTTP/1.1 407\r\n"
       "Proxy-Authenticate: MOCK foo\r\n"
-      "\r\n"));
+      "\r\n");
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
   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);
 
   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_EQ(OK, controller->HandleAuthChallenge(response_info, false, false,
+                                                dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
   controller->ResetAuth(AuthCredentials());
   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)
@@ skipping 34 matching lines @@
 TEST(HttpAuthControllerTest, NoExplicitCredentialsAllowed) {
   // Modified mock HttpAuthHandler for this test.
   class MockHandler : public HttpAuthHandlerMock {
    public:
     MockHandler(int expected_rv, HttpAuth::Scheme scheme)
         : expected_scheme_(scheme) {
       SetGenerateExpectation(false, expected_rv);
     }
 
    protected:
-    bool Init(HttpAuthChallengeTokenizer* challenge) override {
-      HttpAuthHandlerMock::Init(challenge);
+    bool Init(HttpAuthChallengeTokenizer* challenge,
+              const HttpResponseInfo& response_info) override {
+      HttpAuthHandlerMock::Init(challenge, response_info);
       set_allows_default_credentials(true);
       set_allows_explicit_credentials(false);
       set_connection_based(true);
       // 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_);
@@ skipping 17 matching lines @@
    private:
     HttpAuth::Scheme 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(
+  HttpResponseInfo response_info;
+  response_info.headers = HeadersFromString(
       "HTTP/1.1 401\r\n"
       "WWW-Authenticate: Mock\r\n"
       "WWW-Authenticate: Basic\r\n"
-      "\r\n"));
+      "\r\n");
 
   HttpAuthHandlerMock::Factory auth_handler_factory;
 
   // Handlers for the first attempt at authentication.  AUTH_SCHEME_MOCK handler
   // accepts the default identity and successfully constructs a token.
   auth_handler_factory.AddMockHandler(
       new MockHandler(OK, HttpAuth::AUTH_SCHEME_MOCK), HttpAuth::AUTH_SERVER);
   auth_handler_factory.AddMockHandler(
       new MockHandler(ERR_UNEXPECTED, HttpAuth::AUTH_SCHEME_BASIC),
       HttpAuth::AUTH_SERVER);
@@ skipping 16 matching lines @@
       HttpAuth::AUTH_SERVER);
   auth_handler_factory.AddMockHandler(
       new MockHandler(OK, HttpAuth::AUTH_SCHEME_BASIC),
       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_EQ(OK, controller->HandleAuthChallenge(response_info, false, false,
+                                                dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
   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, CompletionCallback(), dummy_log));
+  HttpRequestHeaders request_headers;
   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_EQ(OK, controller->HandleAuthChallenge(response_info, false, false,
+                                                dummy_log));
   ASSERT_TRUE(controller->HaveAuthHandler());
   controller->ResetAuth(AuthCredentials(base::ASCIIToUTF16("Hello"),
                         base::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, CompletionCallback(), dummy_log));
 }
 
 }  // namespace net