Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(27)

Side by Side Diff: net/http/http_network_transaction_unittest.cc

Issue 9148011: Allow chrome to handle 407 auth challenges to CONNECT requests (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Address feedback from both vandebo and akalin Created 8 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/http/http_network_transaction.h" 5 #include "net/http/http_network_transaction.h"
6 6
7 #include <math.h> // ceil 7 #include <math.h> // ceil
8 #include <stdarg.h> 8 #include <stdarg.h>
9 #include <string> 9 #include <string>
10 #include <vector> 10 #include <vector>
(...skipping 403 matching lines...) Expand 10 before | Expand all | Expand 10 after
414 bool CheckNTLMServerAuth(const AuthChallengeInfo* auth_challenge) { 414 bool CheckNTLMServerAuth(const AuthChallengeInfo* auth_challenge) {
415 if (!auth_challenge) 415 if (!auth_challenge)
416 return false; 416 return false;
417 EXPECT_FALSE(auth_challenge->is_proxy); 417 EXPECT_FALSE(auth_challenge->is_proxy);
418 EXPECT_EQ("172.22.68.17:80", auth_challenge->challenger.ToString()); 418 EXPECT_EQ("172.22.68.17:80", auth_challenge->challenger.ToString());
419 EXPECT_EQ(std::string(), auth_challenge->realm); 419 EXPECT_EQ(std::string(), auth_challenge->realm);
420 EXPECT_EQ("ntlm", auth_challenge->scheme); 420 EXPECT_EQ("ntlm", auth_challenge->scheme);
421 return true; 421 return true;
422 } 422 }
423 423
424 bool CheckNTLMProxyAuth(const AuthChallengeInfo* auth_challenge) {
425 if (!auth_challenge)
426 return false;
427 EXPECT_TRUE(auth_challenge->is_proxy);
428 EXPECT_EQ("proxy:70", auth_challenge->challenger.ToString());
429 EXPECT_EQ(std::string(), auth_challenge->realm);
430 EXPECT_EQ("ntlm", auth_challenge->scheme);
431 return true;
432 }
433
424 TEST_F(HttpNetworkTransactionTest, Basic) { 434 TEST_F(HttpNetworkTransactionTest, Basic) {
425 SessionDependencies session_deps; 435 SessionDependencies session_deps;
426 scoped_ptr<HttpTransaction> trans( 436 scoped_ptr<HttpTransaction> trans(
427 new HttpNetworkTransaction(CreateSession(&session_deps))); 437 new HttpNetworkTransaction(CreateSession(&session_deps)));
428 } 438 }
429 439
430 TEST_F(HttpNetworkTransactionTest, SimpleGET) { 440 TEST_F(HttpNetworkTransactionTest, SimpleGET) {
431 MockRead data_reads[] = { 441 MockRead data_reads[] = {
432 MockRead("HTTP/1.0 200 OK\r\n\r\n"), 442 MockRead("HTTP/1.0 200 OK\r\n\r\n"),
433 MockRead("hello world"), 443 MockRead("hello world"),
(...skipping 1277 matching lines...) Expand 10 before | Expand all | Expand 10 after
1711 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); 1721 CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
1712 session_deps.net_log = log.bound().net_log(); 1722 session_deps.net_log = log.bound().net_log();
1713 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); 1723 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
1714 1724
1715 // Since we have proxy, should try to establish tunnel. 1725 // Since we have proxy, should try to establish tunnel.
1716 MockWrite data_writes1[] = { 1726 MockWrite data_writes1[] = {
1717 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" 1727 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
1718 "Host: www.google.com\r\n" 1728 "Host: www.google.com\r\n"
1719 "Proxy-Connection: keep-alive\r\n\r\n"), 1729 "Proxy-Connection: keep-alive\r\n\r\n"),
1720 1730
1731 };
1732
1733 MockWrite data_writes2[] = {
1721 // After calling trans->RestartWithAuth(), this is the request we should 1734 // After calling trans->RestartWithAuth(), this is the request we should
1722 // be issuing -- the final header line contains the credentials. 1735 // be issuing -- the final header line contains the credentials.
1723 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" 1736 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
1724 "Host: www.google.com\r\n" 1737 "Host: www.google.com\r\n"
1725 "Proxy-Connection: keep-alive\r\n" 1738 "Proxy-Connection: keep-alive\r\n"
1726 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), 1739 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1727 1740
1728 MockWrite("GET / HTTP/1.1\r\n" 1741 MockWrite("GET / HTTP/1.1\r\n"
1729 "Host: www.google.com\r\n" 1742 "Host: www.google.com\r\n"
1730 "Connection: keep-alive\r\n\r\n"), 1743 "Connection: keep-alive\r\n\r\n"),
1731 }; 1744 };
1732 1745
1733 // The proxy responds to the connect with a 407, using a persistent 1746 // The proxy responds to the connect with a 407, using a persistent
1734 // connection. 1747 // connection.
1735 MockRead data_reads1[] = { 1748 MockRead data_reads1[] = {
1736 // No credentials. 1749 // No credentials.
1737 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), 1750 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
1738 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), 1751 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
1739 MockRead("Proxy-Connection: close\r\n\r\n"), 1752 MockRead("Proxy-Connection: close\r\n\r\n"),
1753 };
1740 1754
1755 MockRead data_reads2[] = {
1741 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), 1756 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
1742 1757
1743 MockRead("HTTP/1.1 200 OK\r\n"), 1758 MockRead("HTTP/1.1 200 OK\r\n"),
1744 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"), 1759 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
1745 MockRead("Content-Length: 5\r\n\r\n"), 1760 MockRead("Content-Length: 5\r\n\r\n"),
1746 MockRead(false, "hello"), 1761 MockRead(false, "hello"),
1747 }; 1762 };
1748 1763
1749 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 1764 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
1750 data_writes1, arraysize(data_writes1)); 1765 data_writes1, arraysize(data_writes1));
1766 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
1767 data_writes2, arraysize(data_writes2));
1751 session_deps.socket_factory.AddSocketDataProvider(&data1); 1768 session_deps.socket_factory.AddSocketDataProvider(&data1);
1769 session_deps.socket_factory.AddSocketDataProvider(&data2);
1752 SSLSocketDataProvider ssl(true, OK); 1770 SSLSocketDataProvider ssl(true, OK);
1753 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); 1771 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
1754 1772
1755 TestCompletionCallback callback1; 1773 TestCompletionCallback callback1;
1756 1774
1757 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); 1775 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
1758 1776
1759 int rv = trans->Start(&request, callback1.callback(), log.bound()); 1777 int rv = trans->Start(&request, callback1.callback(), log.bound());
1760 EXPECT_EQ(ERR_IO_PENDING, rv); 1778 EXPECT_EQ(ERR_IO_PENDING, rv);
1761 1779
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after
1956 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); 1974 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
1957 1975
1958 std::string response_data; 1976 std::string response_data;
1959 rv = ReadTransaction(trans.get(), &response_data); 1977 rv = ReadTransaction(trans.get(), &response_data);
1960 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); 1978 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
1961 1979
1962 // Flush the idle socket before the HttpNetworkTransaction goes out of scope. 1980 // Flush the idle socket before the HttpNetworkTransaction goes out of scope.
1963 session->CloseAllConnections(); 1981 session->CloseAllConnections();
1964 } 1982 }
1965 1983
1984 // Test the request-challenge-retry sequence for basic auth, over a connection
1985 // that requires a restart when setting up an SSL tunnel.
1986 TEST_F(HttpNetworkTransactionTest, BasicAuthHttpsProxyNoKeepAlive) {
1987 HttpRequestInfo request;
1988 request.method = "GET";
1989 request.url = GURL("https://www.google.com/");
1990 // when the no authentication data flag is set.
1991 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
1992
1993 // Configure against https proxy server "myproxy:70".
1994 SessionDependencies session_deps(
1995 ProxyService::CreateFixed("https://myproxy:70"));
1996 CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
1997 session_deps.net_log = log.bound().net_log();
1998 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
1999
2000 // Since we have proxy, should try to establish tunnel.
2001 MockWrite data_writes1[] = {
2002 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
2003 "Host: www.google.com\r\n"
2004 "Proxy-Connection: keep-alive\r\n\r\n"),
2005 };
2006
2007 MockWrite data_writes2[] = {
2008 // After calling trans->RestartWithAuth(), this is the request we should
2009 // be issuing -- the final header line contains the credentials.
2010 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
2011 "Host: www.google.com\r\n"
2012 "Proxy-Connection: keep-alive\r\n"
2013 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
2014
2015 MockWrite("GET / HTTP/1.1\r\n"
2016 "Host: www.google.com\r\n"
2017 "Connection: keep-alive\r\n\r\n"),
2018 };
2019
2020 // The proxy responds to the connect with a 407, using a persistent
2021 // connection.
2022 MockRead data_reads1[] = {
2023 // No credentials.
2024 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
2025 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
2026 MockRead("Proxy-Connection: close\r\n\r\n"),
2027 };
2028
2029 MockRead data_reads2[] = {
2030 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
2031
2032 MockRead("HTTP/1.1 200 OK\r\n"),
2033 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
2034 MockRead("Content-Length: 5\r\n\r\n"),
2035 MockRead(false, "hello"),
2036 };
2037
2038 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2039 data_writes1, arraysize(data_writes1));
2040 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2041 data_writes2, arraysize(data_writes2));
2042 session_deps.socket_factory.AddSocketDataProvider(&data1);
2043 session_deps.socket_factory.AddSocketDataProvider(&data2);
2044 SSLSocketDataProvider proxy(true, OK);
2045 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy);
2046 SSLSocketDataProvider proxy2(true, OK);
2047 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy2);
2048 SSLSocketDataProvider server(true, OK);
2049 session_deps.socket_factory.AddSSLSocketDataProvider(&server);
2050
2051 TestCompletionCallback callback1;
2052
2053 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
2054
2055 int rv = trans->Start(&request, callback1.callback(), log.bound());
2056 EXPECT_EQ(ERR_IO_PENDING, rv);
2057
2058 rv = callback1.WaitForResult();
2059 EXPECT_EQ(OK, rv);
2060 net::CapturingNetLog::EntryList entries;
2061 log.GetEntries(&entries);
2062 size_t pos = ExpectLogContainsSomewhere(
2063 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
2064 NetLog::PHASE_NONE);
2065 ExpectLogContainsSomewhere(
2066 entries, pos,
2067 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
2068 NetLog::PHASE_NONE);
2069
2070 const HttpResponseInfo* response = trans->GetResponseInfo();
2071 ASSERT_TRUE(response != NULL);
2072 ASSERT_FALSE(response->headers == NULL);
2073 EXPECT_EQ(407, response->headers->response_code());
2074 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2075 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
2076
2077 TestCompletionCallback callback2;
2078
2079 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar),
2080 callback2.callback());
2081 EXPECT_EQ(ERR_IO_PENDING, rv);
2082
2083 rv = callback2.WaitForResult();
2084 EXPECT_EQ(OK, rv);
2085
2086 response = trans->GetResponseInfo();
2087 ASSERT_TRUE(response != NULL);
2088
2089 EXPECT_TRUE(response->headers->IsKeepAlive());
2090 EXPECT_EQ(200, response->headers->response_code());
2091 EXPECT_EQ(5, response->headers->GetContentLength());
2092 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2093
2094 // The password prompt info should not be set.
2095 EXPECT_TRUE(response->auth_challenge.get() == NULL);
2096
2097 trans.reset();
2098 session->CloseAllConnections();
2099 }
2100
2101 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
2102 // proxy connection, when setting up an SSL tunnel.
2103 TEST_F(HttpNetworkTransactionTest, BasicAuthHttpsProxyKeepAlive) {
2104 HttpRequestInfo request;
2105 request.method = "GET";
2106 request.url = GURL("https://www.google.com/");
2107 // Ensure that proxy authentication is attempted even
2108 // when the no authentication data flag is set.
2109 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
2110
2111 // Configure against https proxy server "myproxy:70".
2112 SessionDependencies session_deps(
2113 ProxyService::CreateFixed("https://myproxy:70"));
2114 CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
2115 session_deps.net_log = log.bound().net_log();
2116 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
2117
2118 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
2119
2120 // Since we have proxy, should try to establish tunnel.
2121 MockWrite data_writes1[] = {
2122 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
2123 "Host: www.google.com\r\n"
2124 "Proxy-Connection: keep-alive\r\n\r\n"),
2125
2126 // After calling trans->RestartWithAuth(), this is the request we should
2127 // be issuing -- the final header line contains the credentials.
2128 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
2129 "Host: www.google.com\r\n"
2130 "Proxy-Connection: keep-alive\r\n"
2131 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"),
2132 };
2133
2134 // The proxy responds to the connect with a 407, using a persistent
2135 // connection.
2136 MockRead data_reads1[] = {
2137 // No credentials.
2138 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
2139 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
2140 MockRead("Content-Length: 10\r\n\r\n"),
2141 MockRead("0123456789"),
2142
2143 // Wrong credentials (wrong password).
2144 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
2145 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
2146 MockRead("Content-Length: 10\r\n\r\n"),
2147 // No response body because the test stops reading here.
2148 MockRead(false, ERR_UNEXPECTED), // Should not be reached.
2149 };
2150
2151 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2152 data_writes1, arraysize(data_writes1));
2153 session_deps.socket_factory.AddSocketDataProvider(&data1);
2154 SSLSocketDataProvider ssl(true, OK);
2155 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
2156
2157 TestCompletionCallback callback1;
2158
2159 int rv = trans->Start(&request, callback1.callback(), log.bound());
2160 EXPECT_EQ(ERR_IO_PENDING, rv);
2161
2162 rv = callback1.WaitForResult();
2163 EXPECT_EQ(OK, rv);
2164 net::CapturingNetLog::EntryList entries;
2165 log.GetEntries(&entries);
2166 size_t pos = ExpectLogContainsSomewhere(
2167 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
2168 NetLog::PHASE_NONE);
2169 ExpectLogContainsSomewhere(
2170 entries, pos,
2171 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
2172 NetLog::PHASE_NONE);
2173
2174 const HttpResponseInfo* response = trans->GetResponseInfo();
2175 ASSERT_TRUE(response != NULL);
2176 ASSERT_FALSE(response->headers == NULL);
2177 EXPECT_TRUE(response->headers->IsKeepAlive());
2178 EXPECT_EQ(407, response->headers->response_code());
2179 EXPECT_EQ(10, response->headers->GetContentLength());
2180 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2181 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
2182
2183 TestCompletionCallback callback2;
2184
2185 // Wrong password (should be "bar").
2186 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBaz),
2187 callback2.callback());
2188 EXPECT_EQ(ERR_IO_PENDING, rv);
2189
2190 rv = callback2.WaitForResult();
2191 EXPECT_EQ(OK, rv);
2192
2193 response = trans->GetResponseInfo();
2194 ASSERT_TRUE(response != NULL);
2195 ASSERT_FALSE(response->headers == NULL);
2196 EXPECT_TRUE(response->headers->IsKeepAlive());
2197 EXPECT_EQ(407, response->headers->response_code());
2198 EXPECT_EQ(10, response->headers->GetContentLength());
2199 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2200 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
2201
2202 // Flush the idle socket before the NetLog and HttpNetworkTransaction go
2203 // out of scope.
2204 session->CloseAllConnections();
2205 }
2206
2207 // Test the request-challenge-retry sequence for basic auth, through
2208 // a SPDY proxy over a single SPDY session.
2209 TEST_F(HttpNetworkTransactionTest, BasicAuthSpdyProxy) {
2210 HttpRequestInfo request;
2211 request.method = "GET";
2212 request.url = GURL("https://www.google.com/");
2213 // when the no authentication data flag is set.
2214 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
2215
2216 // Configure against https proxy server "myproxy:70".
2217 SessionDependencies session_deps(
2218 ProxyService::CreateFixed("https://myproxy:70"));
2219 CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
2220 session_deps.net_log = log.bound().net_log();
2221 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
2222
2223 // Since we have proxy, should try to establish tunnel.
2224 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(NULL, 0, 1));
2225 scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL));
2226
2227 // After calling trans->RestartWithAuth(), this is the request we should
2228 // be issuing -- the final header line contains the credentials.
2229 const char* const kAuthCredentials[] = {
2230 "proxy-authorization", "Basic Zm9vOmJhcg==",
2231 };
2232 scoped_ptr<spdy::SpdyFrame> connect2(
2233 ConstructSpdyConnect(kAuthCredentials, arraysize(kAuthCredentials)/2, 3));
2234 // fetch https://www.google.com/ via HTTP
2235 const char get[] = "GET / HTTP/1.1\r\n"
2236 "Host: www.google.com\r\n"
2237 "Connection: keep-alive\r\n\r\n";
2238 scoped_ptr<spdy::SpdyFrame> wrapped_get(
2239 ConstructSpdyBodyFrame(3, get, strlen(get), false));
2240
2241 MockWrite spdy_writes[] = {
2242 CreateMockWrite(*req, 0, true),
2243 CreateMockWrite(*rst, 2, true),
2244 CreateMockWrite(*connect2, 3),
2245 CreateMockWrite(*wrapped_get, 5)
2246 };
2247
2248 // The proxy responds to the connect with a 407, using a persistent
2249 // connection.
2250 const char* const kAuthChallenge[] = {
2251 "status", "407 Proxy Authentication Required",
2252 "version", "HTTP/1.1",
2253 "proxy-authenticate", "Basic realm=\"MyRealm1\"",
2254 };
2255
2256 scoped_ptr<spdy::SpdyFrame> conn_auth_resp(
2257 ConstructSpdyControlFrame(NULL,
2258 0,
2259 false,
2260 1,
2261 LOWEST,
2262 spdy::SYN_REPLY,
2263 spdy::CONTROL_FLAG_NONE,
2264 kAuthChallenge,
2265 arraysize(kAuthChallenge)));
2266
2267 scoped_ptr<spdy::SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
2268 const char resp[] = "HTTP/1.1 200 OK\r\n"
2269 "Content-Length: 5\r\n\r\n";
2270
2271 scoped_ptr<spdy::SpdyFrame> wrapped_get_resp(
2272 ConstructSpdyBodyFrame(3, resp, strlen(resp), false));
2273 scoped_ptr<spdy::SpdyFrame> wrapped_body(
2274 ConstructSpdyBodyFrame(3, "hello", 5, false));
2275 MockRead spdy_reads[] = {
2276 CreateMockRead(*conn_auth_resp, 1, true),
2277 CreateMockRead(*conn_resp, 4, true),
2278 CreateMockRead(*wrapped_get_resp, 5, true),
2279 CreateMockRead(*wrapped_body, 6, true),
2280 MockRead(false, ERR_IO_PENDING),
2281 };
2282
2283 scoped_refptr<OrderedSocketData> spdy_data(
2284 new OrderedSocketData(
2285 spdy_reads, arraysize(spdy_reads),
2286 spdy_writes, arraysize(spdy_writes)));
2287 session_deps.socket_factory.AddSocketDataProvider(spdy_data);
2288 // Negotiate SPDY to the proxy
2289 SSLSocketDataProvider proxy(true, OK);
2290 proxy.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
2291 proxy.next_proto = "spdy/2";
2292 proxy.was_npn_negotiated = true;
2293 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy);
2294 // Vanilla SSL to the server
2295 SSLSocketDataProvider server(true, OK);
2296 session_deps.socket_factory.AddSSLSocketDataProvider(&server);
2297
2298 TestCompletionCallback callback1;
2299
2300 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
2301
2302 int rv = trans->Start(&request, callback1.callback(), log.bound());
2303 EXPECT_EQ(ERR_IO_PENDING, rv);
2304
2305 rv = callback1.WaitForResult();
2306 EXPECT_EQ(OK, rv);
2307 net::CapturingNetLog::EntryList entries;
2308 log.GetEntries(&entries);
2309 size_t pos = ExpectLogContainsSomewhere(
2310 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
2311 NetLog::PHASE_NONE);
2312 ExpectLogContainsSomewhere(
2313 entries, pos,
2314 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
2315 NetLog::PHASE_NONE);
2316
2317 const HttpResponseInfo* response = trans->GetResponseInfo();
2318 ASSERT_TRUE(response != NULL);
2319 ASSERT_FALSE(response->headers == NULL);
2320 EXPECT_EQ(407, response->headers->response_code());
2321 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2322 EXPECT_TRUE(response->auth_challenge.get() != NULL);
2323 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
2324
2325 TestCompletionCallback callback2;
2326
2327 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar),
2328 callback2.callback());
2329 EXPECT_EQ(ERR_IO_PENDING, rv);
2330
2331 rv = callback2.WaitForResult();
2332 EXPECT_EQ(OK, rv);
2333
2334 response = trans->GetResponseInfo();
2335 ASSERT_TRUE(response != NULL);
2336
2337 EXPECT_TRUE(response->headers->IsKeepAlive());
2338 EXPECT_EQ(200, response->headers->response_code());
2339 EXPECT_EQ(5, response->headers->GetContentLength());
2340 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
2341
2342 // The password prompt info should not be set.
2343 EXPECT_TRUE(response->auth_challenge.get() == NULL);
2344
2345 trans.reset();
2346 session->CloseAllConnections();
2347 }
2348
2349
1966 // Test when a server (non-proxy) returns a 407 (proxy-authenticate). 2350 // Test when a server (non-proxy) returns a 407 (proxy-authenticate).
1967 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH. 2351 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH.
1968 TEST_F(HttpNetworkTransactionTest, UnexpectedProxyAuth) { 2352 TEST_F(HttpNetworkTransactionTest, UnexpectedProxyAuth) {
1969 HttpRequestInfo request; 2353 HttpRequestInfo request;
1970 request.method = "GET"; 2354 request.method = "GET";
1971 request.url = GURL("http://www.google.com/"); 2355 request.url = GURL("http://www.google.com/");
1972 request.load_flags = 0; 2356 request.load_flags = 0;
1973 2357
1974 // We are using a DIRECT connection (i.e. no proxy) for this session. 2358 // We are using a DIRECT connection (i.e. no proxy) for this session.
1975 SessionDependencies session_deps; 2359 SessionDependencies session_deps;
(...skipping 1082 matching lines...) Expand 10 before | Expand all | Expand 10 after
3058 3442
3059 rv = callback3.WaitForResult(); 3443 rv = callback3.WaitForResult();
3060 EXPECT_EQ(OK, rv); 3444 EXPECT_EQ(OK, rv);
3061 3445
3062 response = trans->GetResponseInfo(); 3446 response = trans->GetResponseInfo();
3063 ASSERT_TRUE(response != NULL); 3447 ASSERT_TRUE(response != NULL);
3064 EXPECT_TRUE(response->auth_challenge.get() == NULL); 3448 EXPECT_TRUE(response->auth_challenge.get() == NULL);
3065 EXPECT_EQ(13, response->headers->GetContentLength()); 3449 EXPECT_EQ(13, response->headers->GetContentLength());
3066 } 3450 }
3067 3451
3452
3453 // Enter the correct password and authenticate successfully.
3454 TEST_F(HttpNetworkTransactionTest, NTLMAuthFull) {
cbentzel 2012/01/20 02:09:46 Should the name/description of this test include a
Ryan Hamilton 2012/01/20 04:20:04 Done.
3455 HttpRequestInfo request;
3456 request.method = "GET";
3457 request.url = GURL("https://www.google.com/");
3458 request.load_flags = 0;
3459
3460 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom1,
3461 MockGetHostName);
3462 SessionDependencies session_deps(ProxyService::CreateFixed(
3463 "https://proxy:70"));
3464
3465 MockWrite data_writes1[] = {
3466 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
3467 "Host: www.google.com\r\n"
3468 "Proxy-Connection: keep-alive\r\n\r\n"),
3469 };
3470
3471 MockRead data_reads1[] = {
3472 MockRead("HTTP/1.1 407 Access Denied\r\n"),
3473 // Negotiate and NTLM are often requested together. However, we only want
3474 // to test NTLM. Since Negotiate is preferred over NTLM, we have to skip
3475 // the header that requests Negotiate for this test.
3476 MockRead("Proxy-Authenticate: NTLM\r\n"),
3477 MockRead("Connection: close\r\n"),
3478 MockRead("Content-Length: 42\r\n"),
3479 MockRead("Content-Type: text/html\r\n\r\n"),
3480 // Missing content -- won't matter, as connection will be reset.
3481 MockRead(false, ERR_UNEXPECTED),
3482 };
3483
3484 MockWrite data_writes2[] = {
3485 // After restarting with a null identity, this is the
3486 // request we should be issuing -- the final header line contains a Type
3487 // 1 message.
3488 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
3489 "Host: www.google.com\r\n"
3490 "Proxy-Connection: keep-alive\r\n"
3491 "Proxy-Authorization: NTLM "
3492 "TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=\r\n\r\n"),
3493
3494 // After calling trans->RestartWithAuth(), we should send a Type 3 message
3495 // (the credentials for the origin server). The second request continues
3496 // on the same connection.
3497 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
3498 "Host: www.google.com\r\n"
3499 "Proxy-Connection: keep-alive\r\n"
3500 "Proxy-Authorization: NTLM TlRMTVNTUAADAAAAGAAYAGgAAAAYABgAgA"
3501 "AAAAAAAABAAAAAGAAYAEAAAAAQABAAWAAAAAAAAAAAAAAABYIIAHQA"
3502 "ZQBzAHQAaQBuAGcALQBuAHQAbABtAFcAVABDAC0AVwBJAE4ANwBVKW"
3503 "Yma5xzVAAAAAAAAAAAAAAAAAAAAACH+gWcm+YsP9Tqb9zCR3WAeZZX"
3504 "ahlhx5I=\r\n\r\n"),
3505
3506 MockWrite("GET / HTTP/1.1\r\n"
3507 "Host: www.google.com\r\n"
3508 "Connection: keep-alive\r\n\r\n"),
3509 };
3510
3511 MockRead data_reads2[] = {
3512 // The origin server responds with a Type 2 message.
3513 MockRead("HTTP/1.1 407 Access Denied\r\n"),
3514 MockRead("Proxy-Authenticate: NTLM "
3515 "TlRMTVNTUAACAAAADAAMADgAAAAFgokCjGpMpPGlYKkAAAAAAAAAALo"
3516 "AugBEAAAABQEoCgAAAA9HAE8ATwBHAEwARQACAAwARwBPAE8ARwBMAE"
3517 "UAAQAaAEEASwBFAEUAUwBBAFIAQQAtAEMATwBSAFAABAAeAGMAbwByA"
3518 "HAALgBnAG8AbwBnAGwAZQAuAGMAbwBtAAMAQABhAGsAZQBlAHMAYQBy"
3519 "AGEALQBjAG8AcgBwAC4AYQBkAC4AYwBvAHIAcAAuAGcAbwBvAGcAbAB"
3520 "lAC4AYwBvAG0ABQAeAGMAbwByAHAALgBnAG8AbwBnAGwAZQAuAGMAbw"
3521 "BtAAAAAAA=\r\n"),
3522 MockRead("Content-Length: 42\r\n"),
3523 MockRead("Content-Type: text/html\r\n\r\n"),
3524 MockRead("You are not authorized to view this page\r\n"),
3525
3526 // Connect succeeds
3527 MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
3528
3529 // Lastly we get the desired content.
3530 MockRead("HTTP/1.1 200 OK\r\n"),
3531 MockRead("Content-Type: text/html; charset=utf-8\r\n"),
3532 MockRead("Content-Length: 13\r\n\r\n"),
3533 MockRead("Please Login\r\n"),
3534 MockRead(false, OK),
3535 };
3536
3537 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
3538 data_writes1, arraysize(data_writes1));
3539 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
3540 data_writes2, arraysize(data_writes2));
3541 SSLSocketDataProvider ssl(true, OK);
3542 SSLSocketDataProvider ssl2(true, OK);
3543 SSLSocketDataProvider ssl3(true, OK);
3544 SSLSocketDataProvider ssl_server(true, OK);
3545 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
3546 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
3547 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl3);
3548 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_server);
3549 session_deps.socket_factory.AddSocketDataProvider(&data1);
3550 session_deps.socket_factory.AddSocketDataProvider(&data2);
3551 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
3552
3553 TestCompletionCallback callback1;
3554
3555 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
3556
3557 int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
3558 EXPECT_EQ(ERR_IO_PENDING, rv);
3559
3560 rv = callback1.WaitForResult();
3561 EXPECT_EQ(OK, rv);
3562
3563 EXPECT_FALSE(trans->IsReadyToRestartForAuth());
3564
3565 const HttpResponseInfo* response = trans->GetResponseInfo();
3566 ASSERT_FALSE(response == NULL);
3567 EXPECT_TRUE(CheckNTLMProxyAuth(response->auth_challenge.get()));
3568
3569 TestCompletionCallback callback2;
3570
3571 rv = trans->RestartWithAuth(AuthCredentials(kTestingNTLM, kTestingNTLM),
3572 callback2.callback());
3573 EXPECT_EQ(ERR_IO_PENDING, rv);
3574
3575 rv = callback2.WaitForResult();
3576 EXPECT_EQ(OK, rv);
3577
3578 EXPECT_TRUE(trans->IsReadyToRestartForAuth());
3579
3580 response = trans->GetResponseInfo();
3581 ASSERT_TRUE(response != NULL);
3582 EXPECT_TRUE(response->auth_challenge.get() == NULL);
3583
3584 TestCompletionCallback callback3;
3585
3586 rv = trans->RestartWithAuth(AuthCredentials(), callback3.callback());
3587 EXPECT_EQ(ERR_IO_PENDING, rv);
3588
3589 rv = callback3.WaitForResult();
3590 EXPECT_EQ(OK, rv);
3591
3592 response = trans->GetResponseInfo();
3593 ASSERT_TRUE(response != NULL);
3594 EXPECT_TRUE(response->auth_challenge.get() == NULL);
3595 EXPECT_EQ(13, response->headers->GetContentLength());
3596 }
3597
3068 // Enter a wrong password, and then the correct one. 3598 // Enter a wrong password, and then the correct one.
3069 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { 3599 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) {
3070 HttpRequestInfo request; 3600 HttpRequestInfo request;
3071 request.method = "GET"; 3601 request.method = "GET";
3072 request.url = GURL("http://172.22.68.17/kids/login.aspx"); 3602 request.url = GURL("http://172.22.68.17/kids/login.aspx");
3073 request.load_flags = 0; 3603 request.load_flags = 0;
3074 3604
3075 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2, 3605 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2,
3076 MockGetHostName); 3606 MockGetHostName);
3077 SessionDependencies session_deps; 3607 SessionDependencies session_deps;
(...skipping 4313 matching lines...) Expand 10 before | Expand all | Expand 10 after
7391 } 7921 }
7392 7922
7393 // GenerateAuthToken is a mighty big test. 7923 // GenerateAuthToken is a mighty big test.
7394 // It tests all permutation of GenerateAuthToken behavior: 7924 // It tests all permutation of GenerateAuthToken behavior:
7395 // - Synchronous and Asynchronous completion. 7925 // - Synchronous and Asynchronous completion.
7396 // - OK or error on completion. 7926 // - OK or error on completion.
7397 // - Direct connection, non-authenticating proxy, and authenticating proxy. 7927 // - Direct connection, non-authenticating proxy, and authenticating proxy.
7398 // - HTTP or HTTPS backend (to include proxy tunneling). 7928 // - HTTP or HTTPS backend (to include proxy tunneling).
7399 // - Non-authenticating and authenticating backend. 7929 // - Non-authenticating and authenticating backend.
7400 // 7930 //
7401 // In all, there are 44 reasonable permuations (for example, if there are 7931 // In all, there are 44 reasonable permutations (for example, if there are
7402 // problems generating an auth token for an authenticating proxy, we don't 7932 // problems generating an auth token for an authenticating proxy, we don't
7403 // need to test all permutations of the backend server). 7933 // need to test all permutations of the backend server).
7404 // 7934 //
7405 // The test proceeds by going over each of the configuration cases, and 7935 // The test proceeds by going over each of the configuration cases, and
7406 // potentially running up to three rounds in each of the tests. The TestConfig 7936 // potentially running up to three rounds in each of the tests. The TestConfig
7407 // specifies both the configuration for the test as well as the expectations 7937 // specifies both the configuration for the test as well as the expectations
7408 // for the results. 7938 // for the results.
7409 TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) { 7939 TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) {
7410 static const char kServer[] = "http://www.example.com"; 7940 static const char kServer[] = "http://www.example.com";
7411 static const char kSecureServer[] = "https://www.example.com"; 7941 static const char kSecureServer[] = "https://www.example.com";
(...skipping 837 matching lines...) Expand 10 before | Expand all | Expand 10 after
8249 }; 8779 };
8250 StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1), 8780 StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1),
8251 data_writes_1, arraysize(data_writes_1)); 8781 data_writes_1, arraysize(data_writes_1));
8252 8782
8253 // Second round tries to tunnel to www.google.com due to the 8783 // Second round tries to tunnel to www.google.com due to the
8254 // Alternate-Protocol announcement in the first round. It fails due 8784 // Alternate-Protocol announcement in the first round. It fails due
8255 // to a proxy authentication challenge. 8785 // to a proxy authentication challenge.
8256 // After the failure, a tunnel is established to www.google.com using 8786 // After the failure, a tunnel is established to www.google.com using
8257 // Proxy-Authorization headers. There is then a SPDY request round. 8787 // Proxy-Authorization headers. There is then a SPDY request round.
8258 // 8788 //
8259 // NOTE: Despite the "Proxy-Connection: Close", these are done on the
8260 // same MockTCPClientSocket since the underlying HttpNetworkClientSocket
8261 // does a Disconnect and Connect on the same socket, rather than trying
8262 // to obtain a new one.
8263 //
8264 // NOTE: Originally, the proxy response to the second CONNECT request 8789 // NOTE: Originally, the proxy response to the second CONNECT request
8265 // simply returned another 407 so the unit test could skip the SSL connection 8790 // simply returned another 407 so the unit test could skip the SSL connection
8266 // establishment and SPDY framing issues. Alas, the 8791 // establishment and SPDY framing issues. Alas, the
8267 // retry-http-when-alternate-protocol fails logic kicks in, which was more 8792 // retry-http-when-alternate-protocol fails logic kicks in, which was more
8268 // complicated to set up expectations for than the SPDY session. 8793 // complicated to set up expectations for than the SPDY session.
8269 8794
8270 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST)); 8795 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
8271 scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1)); 8796 scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
8272 scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true)); 8797 scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
8273 8798
8274 MockWrite data_writes_2[] = { 8799 MockWrite data_writes_2[] = {
8275 // First connection attempt without Proxy-Authorization. 8800 // First connection attempt without Proxy-Authorization.
8276 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" 8801 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
8277 "Host: www.google.com\r\n" 8802 "Host: www.google.com\r\n"
8278 "Proxy-Connection: keep-alive\r\n" 8803 "Proxy-Connection: keep-alive\r\n"
8279 "\r\n"), 8804 "\r\n"),
8805 };
8280 8806
8807 MockWrite data_writes_3[] = {
8808 // Non-alternate protocol job that will run in parallel
8809 MockWrite("GET https://www.google.com/ HTTP/1.1\r\n"
8810 "Host: www.google.com\r\n"
8811 "Proxy-Connection: keep-alive\r\n"
8812 "\r\n"),
8813 };
8814
8815 MockWrite data_writes_4[] = {
8281 // Second connection attempt with Proxy-Authorization. 8816 // Second connection attempt with Proxy-Authorization.
8282 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" 8817 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
8283 "Host: www.google.com\r\n" 8818 "Host: www.google.com\r\n"
8284 "Proxy-Connection: keep-alive\r\n" 8819 "Proxy-Connection: keep-alive\r\n"
8285 "Proxy-Authorization: auth_token\r\n" 8820 "Proxy-Authorization: auth_token\r\n"
8286 "\r\n"), 8821 "\r\n"),
8287 8822
8288 // SPDY request 8823 // SPDY request
8289 CreateMockWrite(*req), 8824 CreateMockWrite(*req),
8290 }; 8825 };
8291 const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n" 8826 const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n"
8292 "Proxy-Authenticate: Mock\r\n" 8827 "Proxy-Authenticate: Mock\r\n"
8293 "Proxy-Connection: close\r\n" 8828 "Proxy-Connection: close\r\n"
8829 "Content-Length: 0\r\n"
8294 "\r\n"); 8830 "\r\n");
8295 const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n"; 8831 const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
8296 MockRead data_reads_2[] = { 8832 MockRead data_reads_2[] = {
8297 // First connection attempt fails 8833 // First connection attempt fails
8298 MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1), 8834 MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1),
8299 MockRead(true, kRejectConnectResponse, 8835 MockRead(true, kRejectConnectResponse,
8300 arraysize(kRejectConnectResponse) - 1, 1), 8836 arraysize(kRejectConnectResponse) - 1, 1),
8837 };
8301 8838
8839 // Hang forever so we can ensure the alt job wins
8840 MockRead data_reads_3[] = {
8841 MockRead(false, ERR_IO_PENDING),
8842 };
8843
8844 MockRead data_reads_4[] = {
8302 // Second connection attempt passes 8845 // Second connection attempt passes
8303 MockRead(true, kAcceptConnectResponse, 8846 MockRead(true, kAcceptConnectResponse,
8304 arraysize(kAcceptConnectResponse) -1, 4), 8847 arraysize(kAcceptConnectResponse) -1, 1),
8305 8848
8306 // SPDY response 8849 // SPDY response
8307 CreateMockRead(*resp.get(), 6), 8850 CreateMockRead(*resp.get(), 3),
8308 CreateMockRead(*data.get(), 6), 8851 CreateMockRead(*data.get(), 3),
8309 MockRead(true, 0, 0, 6), 8852 MockRead(true, 0, 0, 4),
8310 }; 8853 };
8311 scoped_refptr<OrderedSocketData> data_2( 8854 scoped_refptr<OrderedSocketData> data_2(
8312 new OrderedSocketData(data_reads_2, arraysize(data_reads_2), 8855 new OrderedSocketData(data_reads_2, arraysize(data_reads_2),
8313 data_writes_2, arraysize(data_writes_2))); 8856 data_writes_2, arraysize(data_writes_2)));
8857 scoped_refptr<OrderedSocketData> data_3(
8858 new OrderedSocketData(data_reads_3, arraysize(data_reads_3),
8859 data_writes_3, arraysize(data_writes_3)));
8860 // Hang forever so we can ensure the alt job wins
8861 MockConnect conn_3(false, ERR_IO_PENDING);
8862 data_3->set_connect_data(conn_3);
8863 scoped_refptr<OrderedSocketData> data_4(
8864 new OrderedSocketData(data_reads_4, arraysize(data_reads_4),
8865 data_writes_4, arraysize(data_writes_4)));
8314 8866
8315 SSLSocketDataProvider ssl(true, OK); 8867 SSLSocketDataProvider ssl(true, OK);
8316 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; 8868 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
8317 ssl.next_proto = "spdy/2"; 8869 ssl.next_proto = "spdy/2";
8318 ssl.was_npn_negotiated = true; 8870 ssl.was_npn_negotiated = true;
8319 ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2; 8871 ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
8320 8872
8321 MockConnect never_finishing_connect(false, ERR_IO_PENDING); 8873 MockConnect never_finishing_connect(false, ERR_IO_PENDING);
8322 StaticSocketDataProvider hanging_non_alternate_protocol_socket( 8874 StaticSocketDataProvider hanging_non_alternate_protocol_socket(
8323 NULL, 0, NULL, 0); 8875 NULL, 0, NULL, 0);
8324 hanging_non_alternate_protocol_socket.set_connect_data( 8876 hanging_non_alternate_protocol_socket.set_connect_data(
8325 never_finishing_connect); 8877 never_finishing_connect);
8326 8878
8327 session_deps.socket_factory.AddSocketDataProvider(&data_1); 8879 session_deps.socket_factory.AddSocketDataProvider(&data_1);
8328 session_deps.socket_factory.AddSocketDataProvider(data_2.get()); 8880 session_deps.socket_factory.AddSocketDataProvider(data_2.get());
8881 session_deps.socket_factory.AddSocketDataProvider(data_3.get());
8882 session_deps.socket_factory.AddSocketDataProvider(data_4.get());
8883 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
8329 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); 8884 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
8330 session_deps.socket_factory.AddSocketDataProvider( 8885 session_deps.socket_factory.AddSocketDataProvider(
8331 &hanging_non_alternate_protocol_socket); 8886 &hanging_non_alternate_protocol_socket);
8332 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); 8887 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
8333 8888
8334 // First round should work and provide the Alternate-Protocol state. 8889 // First round should work and provide the Alternate-Protocol state.
8335 TestCompletionCallback callback_1; 8890 TestCompletionCallback callback_1;
8336 scoped_ptr<HttpTransaction> trans_1(new HttpNetworkTransaction(session)); 8891 scoped_ptr<HttpTransaction> trans_1(new HttpNetworkTransaction(session));
8337 int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog()); 8892 int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog());
8338 EXPECT_EQ(ERR_IO_PENDING, rv); 8893 EXPECT_EQ(ERR_IO_PENDING, rv);
(...skipping 1160 matching lines...) Expand 10 before | Expand all | Expand 10 after
9499 session->spdy_session_pool()->HasSession(host_port_proxy_pair_b)); 10054 session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
9500 10055
9501 HttpStreamFactory::set_next_protos(std::vector<std::string>()); 10056 HttpStreamFactory::set_next_protos(std::vector<std::string>());
9502 ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool); 10057 ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool);
9503 ClientSocketPoolManager::set_max_sockets_per_proxy_server( 10058 ClientSocketPoolManager::set_max_sockets_per_proxy_server(
9504 old_max_sockets_per_proxy_server); 10059 old_max_sockets_per_proxy_server);
9505 ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group); 10060 ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group);
9506 } 10061 }
9507 10062
9508 } // namespace net 10063 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698