OLD | NEW |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 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_proxy_client_socket_pool.h" | 5 #include "net/http/http_proxy_client_socket_pool.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
9 #include "base/string_util.h" | 9 #include "base/string_util.h" |
10 #include "base/utf_string_conversions.h" | 10 #include "base/utf_string_conversions.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 #include "net/spdy/spdy_session_pool.h" | 22 #include "net/spdy/spdy_session_pool.h" |
23 #include "testing/gtest/include/gtest/gtest.h" | 23 #include "testing/gtest/include/gtest/gtest.h" |
24 | 24 |
25 namespace net { | 25 namespace net { |
26 | 26 |
27 namespace { | 27 namespace { |
28 | 28 |
29 const int kMaxSockets = 32; | 29 const int kMaxSockets = 32; |
30 const int kMaxSocketsPerGroup = 6; | 30 const int kMaxSocketsPerGroup = 6; |
31 | 31 |
32 class HttpProxyClientSocketPoolTest : public ClientSocketPoolTest { | 32 enum HttpProxyType { |
| 33 HTTP, |
| 34 HTTPS |
| 35 }; |
| 36 |
| 37 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam; |
| 38 |
| 39 class HttpProxyClientSocketPoolTest : public TestWithHttpParam { |
33 protected: | 40 protected: |
34 HttpProxyClientSocketPoolTest() | 41 HttpProxyClientSocketPoolTest() |
35 : ignored_tcp_socket_params_(new TCPSocketParams( | 42 : ssl_config_(), |
| 43 ignored_tcp_socket_params_(new TCPSocketParams( |
36 HostPortPair("proxy", 80), MEDIUM, GURL(), false)), | 44 HostPortPair("proxy", 80), MEDIUM, GURL(), false)), |
| 45 ignored_ssl_socket_params_(new SSLSocketParams( |
| 46 ignored_tcp_socket_params_, NULL, NULL, ProxyServer::SCHEME_DIRECT, |
| 47 "host", ssl_config_, 0, false, false)), |
37 tcp_histograms_(new ClientSocketPoolHistograms("MockTCP")), | 48 tcp_histograms_(new ClientSocketPoolHistograms("MockTCP")), |
38 tcp_socket_pool_(new MockTCPClientSocketPool(kMaxSockets, | 49 tcp_socket_pool_(new MockTCPClientSocketPool(kMaxSockets, |
39 kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)), | 50 kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)), |
| 51 ssl_socket_pool_(new MockSSLClientSocketPool(kMaxSockets, |
| 52 kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)), |
40 http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), | 53 http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
41 session_(new HttpNetworkSession(new MockHostResolver, | 54 session_(new HttpNetworkSession(new MockHostResolver, |
42 ProxyService::CreateNull(), | 55 ProxyService::CreateNull(), |
43 &socket_factory_, | 56 &socket_factory_, |
44 new SSLConfigServiceDefaults, | 57 new SSLConfigServiceDefaults, |
45 new SpdySessionPool(), | 58 new SpdySessionPool(), |
46 http_auth_handler_factory_.get(), | 59 http_auth_handler_factory_.get(), |
47 NULL, | 60 NULL, |
48 NULL)), | 61 NULL)), |
49 notunnel_socket_params_(new HttpProxySocketParams( | |
50 ignored_tcp_socket_params_, GURL("http://host"), "", | |
51 HostPortPair("host", 80), NULL, false)), | |
52 tunnel_socket_params_(new HttpProxySocketParams( | |
53 ignored_tcp_socket_params_, GURL("http://host"), "", | |
54 HostPortPair("host", 80), session_, true)), | |
55 http_proxy_histograms_( | 62 http_proxy_histograms_( |
56 new ClientSocketPoolHistograms("HttpProxyUnitTest")), | 63 new ClientSocketPoolHistograms("HttpProxyUnitTest")), |
57 pool_(new HttpProxyClientSocketPool(kMaxSockets, kMaxSocketsPerGroup, | 64 pool_(new HttpProxyClientSocketPool(kMaxSockets, kMaxSocketsPerGroup, |
58 http_proxy_histograms_, NULL, tcp_socket_pool_, NULL)) { | 65 http_proxy_histograms_, NULL, tcp_socket_pool_, ssl_socket_pool_, |
| 66 NULL)) { |
59 } | 67 } |
60 | 68 |
61 void AddAuthToCache() { | 69 void AddAuthToCache() { |
62 const string16 kFoo(ASCIIToUTF16("foo")); | 70 const string16 kFoo(ASCIIToUTF16("foo")); |
63 const string16 kBar(ASCIIToUTF16("bar")); | 71 const string16 kBar(ASCIIToUTF16("bar")); |
64 session_->auth_cache()->Add(GURL("http://proxy/"), "MyRealm1", "Basic", | 72 session_->auth_cache()->Add(GURL("http://proxy/"), "MyRealm1", "Basic", |
65 "Basic realm=MyRealm1", kFoo, kBar, "/"); | 73 "Basic realm=MyRealm1", kFoo, kBar, "/"); |
66 } | 74 } |
67 | 75 |
68 int StartRequest(const std::string& group_name, RequestPriority priority) { | 76 scoped_refptr<TCPSocketParams> GetTcpParams() { |
69 return StartRequestUsingPool( | 77 if (GetParam() == HTTPS) |
70 pool_, group_name, priority, tunnel_socket_params_); | 78 return scoped_refptr<TCPSocketParams>(); |
| 79 return ignored_tcp_socket_params_; |
71 } | 80 } |
72 | 81 |
| 82 scoped_refptr<SSLSocketParams> GetSslParams() { |
| 83 if (GetParam() == HTTP) |
| 84 return scoped_refptr<SSLSocketParams>(); |
| 85 return ignored_ssl_socket_params_; |
| 86 } |
| 87 |
| 88 // Returns the a correctly constructed HttpProxyParms |
| 89 // for the HTTP or HTTPS proxy. |
| 90 scoped_refptr<HttpProxySocketParams> GetParams(bool tunnel) { |
| 91 return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams( |
| 92 GetTcpParams(), GetSslParams(), GURL("http://host/"), "", |
| 93 HostPortPair("host", 80), session_, tunnel)); |
| 94 } |
| 95 |
| 96 scoped_refptr<HttpProxySocketParams> GetTunnelParams() { |
| 97 return GetParams(true); |
| 98 } |
| 99 |
| 100 scoped_refptr<HttpProxySocketParams> GetNoTunnelParams() { |
| 101 return GetParams(false); |
| 102 } |
| 103 |
| 104 SSLConfig ssl_config_; |
| 105 |
73 scoped_refptr<TCPSocketParams> ignored_tcp_socket_params_; | 106 scoped_refptr<TCPSocketParams> ignored_tcp_socket_params_; |
| 107 scoped_refptr<SSLSocketParams> ignored_ssl_socket_params_; |
74 scoped_refptr<ClientSocketPoolHistograms> tcp_histograms_; | 108 scoped_refptr<ClientSocketPoolHistograms> tcp_histograms_; |
75 MockClientSocketFactory tcp_client_socket_factory_; | 109 MockClientSocketFactory tcp_client_socket_factory_; |
76 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; | 110 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; |
| 111 scoped_refptr<MockSSLClientSocketPool> ssl_socket_pool_; |
77 | 112 |
78 MockClientSocketFactory socket_factory_; | 113 MockClientSocketFactory socket_factory_; |
79 scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_; | 114 scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_; |
80 scoped_refptr<HttpNetworkSession> session_; | 115 scoped_refptr<HttpNetworkSession> session_; |
81 scoped_refptr<HttpProxySocketParams> notunnel_socket_params_; | |
82 scoped_refptr<HttpProxySocketParams> tunnel_socket_params_; | |
83 scoped_refptr<ClientSocketPoolHistograms> http_proxy_histograms_; | 116 scoped_refptr<ClientSocketPoolHistograms> http_proxy_histograms_; |
84 scoped_refptr<HttpProxyClientSocketPool> pool_; | 117 scoped_refptr<HttpProxyClientSocketPool> pool_; |
85 }; | 118 }; |
86 | 119 |
87 TEST_F(HttpProxyClientSocketPoolTest, NoTunnel) { | 120 //----------------------------------------------------------------------------- |
| 121 // All tests are run with three different connection types: SPDY after NPN |
| 122 // negotiation, SPDY without SSL, and SPDY with SSL. |
| 123 INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolTests, |
| 124 HttpProxyClientSocketPoolTest, |
| 125 ::testing::Values(HTTP, HTTPS)); |
| 126 |
| 127 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) { |
88 StaticSocketDataProvider data; | 128 StaticSocketDataProvider data; |
89 data.set_connect_data(MockConnect(false, 0)); | 129 data.set_connect_data(MockConnect(false, 0)); |
90 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 130 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
91 | 131 |
92 ClientSocketHandle handle; | 132 ClientSocketHandle handle; |
93 int rv = handle.Init("a", notunnel_socket_params_, LOW, NULL, pool_, | 133 int rv = handle.Init("a", GetNoTunnelParams(), LOW, NULL, pool_, |
94 BoundNetLog()); | 134 BoundNetLog()); |
95 EXPECT_EQ(OK, rv); | 135 EXPECT_EQ(OK, rv); |
96 EXPECT_TRUE(handle.is_initialized()); | 136 EXPECT_TRUE(handle.is_initialized()); |
97 EXPECT_TRUE(handle.socket()); | 137 EXPECT_TRUE(handle.socket()); |
98 HttpProxyClientSocket* tunnel_socket = | 138 HttpProxyClientSocket* tunnel_socket = |
99 static_cast<HttpProxyClientSocket*>(handle.socket()); | 139 static_cast<HttpProxyClientSocket*>(handle.socket()); |
100 EXPECT_TRUE(tunnel_socket->IsConnected()); | 140 EXPECT_TRUE(tunnel_socket->IsConnected()); |
101 } | 141 } |
102 | 142 |
103 TEST_F(HttpProxyClientSocketPoolTest, NeedAuth) { | 143 TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) { |
104 MockWrite writes[] = { | 144 MockWrite writes[] = { |
105 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 145 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
106 "Host: host\r\n" | 146 "Host: host\r\n" |
107 "Proxy-Connection: keep-alive\r\n\r\n"), | 147 "Proxy-Connection: keep-alive\r\n\r\n"), |
108 }; | 148 }; |
109 MockRead reads[] = { | 149 MockRead reads[] = { |
110 // No credentials. | 150 // No credentials. |
111 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | 151 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
112 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | 152 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
113 MockRead("Content-Length: 10\r\n\r\n"), | 153 MockRead("Content-Length: 10\r\n\r\n"), |
114 MockRead("0123456789"), | 154 MockRead("0123456789"), |
115 }; | 155 }; |
116 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 156 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
117 arraysize(writes)); | 157 arraysize(writes)); |
118 | 158 |
119 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 159 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
120 | 160 |
121 ClientSocketHandle handle; | 161 ClientSocketHandle handle; |
122 TestCompletionCallback callback; | 162 TestCompletionCallback callback; |
123 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 163 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
124 BoundNetLog()); | 164 BoundNetLog()); |
125 EXPECT_EQ(ERR_IO_PENDING, rv); | 165 EXPECT_EQ(ERR_IO_PENDING, rv); |
126 EXPECT_FALSE(handle.is_initialized()); | 166 EXPECT_FALSE(handle.is_initialized()); |
127 EXPECT_FALSE(handle.socket()); | 167 EXPECT_FALSE(handle.socket()); |
128 | 168 |
129 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | 169 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
130 EXPECT_TRUE(handle.is_initialized()); | 170 EXPECT_TRUE(handle.is_initialized()); |
131 EXPECT_TRUE(handle.socket()); | 171 EXPECT_TRUE(handle.socket()); |
132 HttpProxyClientSocket* tunnel_socket = | 172 HttpProxyClientSocket* tunnel_socket = |
133 static_cast<HttpProxyClientSocket*>(handle.socket()); | 173 static_cast<HttpProxyClientSocket*>(handle.socket()); |
134 EXPECT_FALSE(tunnel_socket->IsConnected()); | 174 EXPECT_FALSE(tunnel_socket->IsConnected()); |
135 } | 175 } |
136 | 176 |
137 TEST_F(HttpProxyClientSocketPoolTest, HaveAuth) { | 177 TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) { |
138 MockWrite writes[] = { | 178 MockWrite writes[] = { |
139 MockWrite(false, | 179 MockWrite(false, |
140 "CONNECT host:80 HTTP/1.1\r\n" | 180 "CONNECT host:80 HTTP/1.1\r\n" |
141 "Host: host\r\n" | 181 "Host: host\r\n" |
142 "Proxy-Connection: keep-alive\r\n" | 182 "Proxy-Connection: keep-alive\r\n" |
143 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 183 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
144 }; | 184 }; |
145 MockRead reads[] = { | 185 MockRead reads[] = { |
146 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), | 186 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
147 }; | 187 }; |
148 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 188 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
149 arraysize(writes)); | 189 arraysize(writes)); |
150 data.set_connect_data(MockConnect(false, 0)); | 190 data.set_connect_data(MockConnect(false, 0)); |
151 | 191 |
152 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 192 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
153 AddAuthToCache(); | 193 AddAuthToCache(); |
154 | 194 |
155 ClientSocketHandle handle; | 195 ClientSocketHandle handle; |
156 TestCompletionCallback callback; | 196 TestCompletionCallback callback; |
157 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 197 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
158 BoundNetLog()); | 198 BoundNetLog()); |
159 EXPECT_EQ(OK, rv); | 199 EXPECT_EQ(OK, rv); |
160 EXPECT_TRUE(handle.is_initialized()); | 200 EXPECT_TRUE(handle.is_initialized()); |
161 EXPECT_TRUE(handle.socket()); | 201 EXPECT_TRUE(handle.socket()); |
162 HttpProxyClientSocket* tunnel_socket = | 202 HttpProxyClientSocket* tunnel_socket = |
163 static_cast<HttpProxyClientSocket*>(handle.socket()); | 203 static_cast<HttpProxyClientSocket*>(handle.socket()); |
164 EXPECT_TRUE(tunnel_socket->IsConnected()); | 204 EXPECT_TRUE(tunnel_socket->IsConnected()); |
165 } | 205 } |
166 | 206 |
167 TEST_F(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { | 207 TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { |
168 MockWrite writes[] = { | 208 MockWrite writes[] = { |
169 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 209 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
170 "Host: host\r\n" | 210 "Host: host\r\n" |
171 "Proxy-Connection: keep-alive\r\n" | 211 "Proxy-Connection: keep-alive\r\n" |
172 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 212 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
173 }; | 213 }; |
174 MockRead reads[] = { | 214 MockRead reads[] = { |
175 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 215 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
176 }; | 216 }; |
177 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 217 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
178 arraysize(writes)); | 218 arraysize(writes)); |
179 | 219 |
180 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 220 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
181 AddAuthToCache(); | 221 AddAuthToCache(); |
182 | 222 |
183 ClientSocketHandle handle; | 223 ClientSocketHandle handle; |
184 TestCompletionCallback callback; | 224 TestCompletionCallback callback; |
185 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 225 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
186 BoundNetLog()); | 226 BoundNetLog()); |
187 EXPECT_EQ(ERR_IO_PENDING, rv); | 227 EXPECT_EQ(ERR_IO_PENDING, rv); |
188 EXPECT_FALSE(handle.is_initialized()); | 228 EXPECT_FALSE(handle.is_initialized()); |
189 EXPECT_FALSE(handle.socket()); | 229 EXPECT_FALSE(handle.socket()); |
190 | 230 |
191 EXPECT_EQ(OK, callback.WaitForResult()); | 231 EXPECT_EQ(OK, callback.WaitForResult()); |
192 EXPECT_TRUE(handle.is_initialized()); | 232 EXPECT_TRUE(handle.is_initialized()); |
193 EXPECT_TRUE(handle.socket()); | 233 EXPECT_TRUE(handle.socket()); |
194 HttpProxyClientSocket* tunnel_socket = | 234 HttpProxyClientSocket* tunnel_socket = |
195 static_cast<HttpProxyClientSocket*>(handle.socket()); | 235 static_cast<HttpProxyClientSocket*>(handle.socket()); |
196 EXPECT_TRUE(tunnel_socket->IsConnected()); | 236 EXPECT_TRUE(tunnel_socket->IsConnected()); |
197 } | 237 } |
198 | 238 |
199 TEST_F(HttpProxyClientSocketPoolTest, TCPError) { | 239 TEST_P(HttpProxyClientSocketPoolTest, TCPError) { |
200 StaticSocketDataProvider data; | 240 StaticSocketDataProvider data; |
201 data.set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); | 241 data.set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); |
202 | 242 |
203 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 243 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
204 | 244 |
205 ClientSocketHandle handle; | 245 ClientSocketHandle handle; |
206 TestCompletionCallback callback; | 246 TestCompletionCallback callback; |
207 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 247 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
208 BoundNetLog()); | 248 BoundNetLog()); |
209 EXPECT_EQ(ERR_IO_PENDING, rv); | 249 EXPECT_EQ(ERR_IO_PENDING, rv); |
210 EXPECT_FALSE(handle.is_initialized()); | 250 EXPECT_FALSE(handle.is_initialized()); |
211 EXPECT_FALSE(handle.socket()); | 251 EXPECT_FALSE(handle.socket()); |
212 | 252 |
213 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); | 253 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
214 EXPECT_FALSE(handle.is_initialized()); | 254 EXPECT_FALSE(handle.is_initialized()); |
215 EXPECT_FALSE(handle.socket()); | 255 EXPECT_FALSE(handle.socket()); |
216 } | 256 } |
217 | 257 |
218 TEST_F(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { | 258 TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { |
219 MockWrite writes[] = { | 259 MockWrite writes[] = { |
220 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 260 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
221 "Host: host\r\n" | 261 "Host: host\r\n" |
222 "Proxy-Connection: keep-alive\r\n" | 262 "Proxy-Connection: keep-alive\r\n" |
223 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 263 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
224 }; | 264 }; |
225 MockRead reads[] = { | 265 MockRead reads[] = { |
226 MockRead("HTTP/1.1 200 Conn"), | 266 MockRead("HTTP/1.1 200 Conn"), |
227 MockRead(true, ERR_CONNECTION_CLOSED), | 267 MockRead(true, ERR_CONNECTION_CLOSED), |
228 }; | 268 }; |
229 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 269 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
230 arraysize(writes)); | 270 arraysize(writes)); |
231 | 271 |
232 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 272 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
233 AddAuthToCache(); | 273 AddAuthToCache(); |
234 | 274 |
235 ClientSocketHandle handle; | 275 ClientSocketHandle handle; |
236 TestCompletionCallback callback; | 276 TestCompletionCallback callback; |
237 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 277 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
238 BoundNetLog()); | 278 BoundNetLog()); |
239 EXPECT_EQ(ERR_IO_PENDING, rv); | 279 EXPECT_EQ(ERR_IO_PENDING, rv); |
240 EXPECT_FALSE(handle.is_initialized()); | 280 EXPECT_FALSE(handle.is_initialized()); |
241 EXPECT_FALSE(handle.socket()); | 281 EXPECT_FALSE(handle.socket()); |
242 | 282 |
243 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); | 283 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
244 EXPECT_FALSE(handle.is_initialized()); | 284 EXPECT_FALSE(handle.is_initialized()); |
245 EXPECT_FALSE(handle.socket()); | 285 EXPECT_FALSE(handle.socket()); |
246 } | 286 } |
247 | 287 |
248 TEST_F(HttpProxyClientSocketPoolTest, TunnelSetupError) { | 288 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) { |
249 MockWrite writes[] = { | 289 MockWrite writes[] = { |
250 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 290 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
251 "Host: host\r\n" | 291 "Host: host\r\n" |
252 "Proxy-Connection: keep-alive\r\n" | 292 "Proxy-Connection: keep-alive\r\n" |
253 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 293 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
254 }; | 294 }; |
255 MockRead reads[] = { | 295 MockRead reads[] = { |
256 MockRead("HTTP/1.1 304 Not Modified\r\n\r\n"), | 296 MockRead("HTTP/1.1 304 Not Modified\r\n\r\n"), |
257 }; | 297 }; |
258 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 298 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
259 arraysize(writes)); | 299 arraysize(writes)); |
260 | 300 |
261 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 301 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
262 AddAuthToCache(); | 302 AddAuthToCache(); |
263 | 303 |
264 ClientSocketHandle handle; | 304 ClientSocketHandle handle; |
265 TestCompletionCallback callback; | 305 TestCompletionCallback callback; |
266 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 306 int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, pool_, |
267 BoundNetLog()); | 307 BoundNetLog()); |
268 EXPECT_EQ(ERR_IO_PENDING, rv); | 308 EXPECT_EQ(ERR_IO_PENDING, rv); |
269 EXPECT_FALSE(handle.is_initialized()); | 309 EXPECT_FALSE(handle.is_initialized()); |
270 EXPECT_FALSE(handle.socket()); | 310 EXPECT_FALSE(handle.socket()); |
271 | 311 |
272 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); | 312 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); |
273 EXPECT_FALSE(handle.is_initialized()); | 313 EXPECT_FALSE(handle.is_initialized()); |
274 EXPECT_FALSE(handle.socket()); | 314 EXPECT_FALSE(handle.socket()); |
275 } | 315 } |
276 | 316 |
277 // It would be nice to also test the timeouts in HttpProxyClientSocketPool. | 317 // It would be nice to also test the timeouts in HttpProxyClientSocketPool. |
278 | 318 |
279 } // namespace | 319 } // namespace |
280 | 320 |
281 } // namespace net | 321 } // namespace net |
OLD | NEW |