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" |
| 10 #include "net/base/mock_host_resolver.h" |
9 #include "net/base/net_errors.h" | 11 #include "net/base/net_errors.h" |
| 12 #include "net/base/ssl_config_service_defaults.h" |
10 #include "net/base/test_completion_callback.h" | 13 #include "net/base/test_completion_callback.h" |
| 14 #include "net/http/http_auth_handler_factory.h" |
| 15 #include "net/http/http_network_session.h" |
11 #include "net/http/http_proxy_client_socket.h" | 16 #include "net/http/http_proxy_client_socket.h" |
| 17 #include "net/proxy/proxy_service.h" |
12 #include "net/socket/client_socket_handle.h" | 18 #include "net/socket/client_socket_handle.h" |
13 #include "net/socket/client_socket_pool_histograms.h" | 19 #include "net/socket/client_socket_pool_histograms.h" |
14 #include "net/socket/socket_test_util.h" | 20 #include "net/socket/socket_test_util.h" |
| 21 #include "net/spdy/spdy_session_pool.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 22 #include "testing/gtest/include/gtest/gtest.h" |
16 | 23 |
17 namespace net { | 24 namespace net { |
18 | 25 |
19 namespace { | 26 namespace { |
20 | 27 |
21 const int kMaxSockets = 32; | 28 const int kMaxSockets = 32; |
22 const int kMaxSocketsPerGroup = 6; | 29 const int kMaxSocketsPerGroup = 6; |
23 | 30 |
24 class HttpProxyClientSocketPoolTest : public ClientSocketPoolTest { | 31 class HttpProxyClientSocketPoolTest : public ClientSocketPoolTest { |
25 protected: | 32 protected: |
26 HttpProxyClientSocketPoolTest() | 33 HttpProxyClientSocketPoolTest() |
27 : ignored_tcp_socket_params_(new TCPSocketParams( | 34 : ignored_tcp_socket_params_(new TCPSocketParams( |
28 HostPortPair("proxy", 80), MEDIUM, GURL(), false)), | 35 HostPortPair("proxy", 80), MEDIUM, GURL(), false)), |
29 tcp_histograms_(new ClientSocketPoolHistograms("MockTCP")), | 36 tcp_histograms_(new ClientSocketPoolHistograms("MockTCP")), |
30 tcp_socket_pool_(new MockTCPClientSocketPool(kMaxSockets, | 37 tcp_socket_pool_(new MockTCPClientSocketPool(kMaxSockets, |
31 kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)), | 38 kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)), |
| 39 http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
| 40 session_(new HttpNetworkSession(new MockHostResolver, |
| 41 ProxyService::CreateNull(), |
| 42 &socket_factory_, |
| 43 new SSLConfigServiceDefaults, |
| 44 new SpdySessionPool(), |
| 45 http_auth_handler_factory_.get(), |
| 46 NULL, |
| 47 NULL)), |
32 notunnel_socket_params_(new HttpProxySocketParams( | 48 notunnel_socket_params_(new HttpProxySocketParams( |
33 ignored_tcp_socket_params_, GURL("http://host"), | 49 ignored_tcp_socket_params_, GURL("http://host"), |
34 HostPortPair("host", 80), NULL, false)), | 50 HostPortPair("host", 80), NULL, false)), |
35 auth_controller_(new MockHttpAuthController), | |
36 tunnel_socket_params_(new HttpProxySocketParams( | 51 tunnel_socket_params_(new HttpProxySocketParams( |
37 ignored_tcp_socket_params_, GURL("http://host"), | 52 ignored_tcp_socket_params_, GURL("http://host"), |
38 HostPortPair("host", 80), auth_controller_, true)), | 53 HostPortPair("host", 80), session_, true)), |
39 http_proxy_histograms_( | 54 http_proxy_histograms_( |
40 new ClientSocketPoolHistograms("HttpProxyUnitTest")), | 55 new ClientSocketPoolHistograms("HttpProxyUnitTest")), |
41 pool_(new HttpProxyClientSocketPool(kMaxSockets, kMaxSocketsPerGroup, | 56 pool_(new HttpProxyClientSocketPool(kMaxSockets, kMaxSocketsPerGroup, |
42 http_proxy_histograms_, NULL, tcp_socket_pool_, NULL)) { | 57 http_proxy_histograms_, NULL, tcp_socket_pool_, NULL)) { |
43 } | 58 } |
44 | 59 |
| 60 void AddAuthToCache() { |
| 61 const string16 kFoo(ASCIIToUTF16("foo")); |
| 62 const string16 kBar(ASCIIToUTF16("bar")); |
| 63 session_->auth_cache()->Add(GURL("http://proxy/"), "MyRealm1", "Basic", |
| 64 "Basic realm=MyRealm1", kFoo, kBar, "/"); |
| 65 } |
| 66 |
45 int StartRequest(const std::string& group_name, RequestPriority priority) { | 67 int StartRequest(const std::string& group_name, RequestPriority priority) { |
46 return StartRequestUsingPool( | 68 return StartRequestUsingPool( |
47 pool_, group_name, priority, tunnel_socket_params_); | 69 pool_, group_name, priority, tunnel_socket_params_); |
48 } | 70 } |
49 | 71 |
50 scoped_refptr<TCPSocketParams> ignored_tcp_socket_params_; | 72 scoped_refptr<TCPSocketParams> ignored_tcp_socket_params_; |
51 scoped_refptr<ClientSocketPoolHistograms> tcp_histograms_; | 73 scoped_refptr<ClientSocketPoolHistograms> tcp_histograms_; |
52 MockClientSocketFactory tcp_client_socket_factory_; | 74 MockClientSocketFactory tcp_client_socket_factory_; |
53 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; | 75 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; |
54 | 76 |
| 77 MockClientSocketFactory socket_factory_; |
| 78 scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_; |
| 79 scoped_refptr<HttpNetworkSession> session_; |
55 scoped_refptr<HttpProxySocketParams> notunnel_socket_params_; | 80 scoped_refptr<HttpProxySocketParams> notunnel_socket_params_; |
56 scoped_refptr<MockHttpAuthController> auth_controller_; | |
57 scoped_refptr<HttpProxySocketParams> tunnel_socket_params_; | 81 scoped_refptr<HttpProxySocketParams> tunnel_socket_params_; |
58 scoped_refptr<ClientSocketPoolHistograms> http_proxy_histograms_; | 82 scoped_refptr<ClientSocketPoolHistograms> http_proxy_histograms_; |
59 scoped_refptr<HttpProxyClientSocketPool> pool_; | 83 scoped_refptr<HttpProxyClientSocketPool> pool_; |
60 }; | 84 }; |
61 | 85 |
62 TEST_F(HttpProxyClientSocketPoolTest, NoTunnel) { | 86 TEST_F(HttpProxyClientSocketPoolTest, NoTunnel) { |
63 StaticSocketDataProvider data; | 87 StaticSocketDataProvider data; |
64 data.set_connect_data(MockConnect(false, 0)); | 88 data.set_connect_data(MockConnect(false, 0)); |
65 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 89 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
66 | 90 |
67 ClientSocketHandle handle; | 91 ClientSocketHandle handle; |
68 int rv = handle.Init("a", notunnel_socket_params_, LOW, NULL, pool_, | 92 int rv = handle.Init("a", notunnel_socket_params_, LOW, NULL, pool_, |
69 BoundNetLog()); | 93 BoundNetLog()); |
70 EXPECT_EQ(OK, rv); | 94 EXPECT_EQ(OK, rv); |
71 EXPECT_TRUE(handle.is_initialized()); | 95 EXPECT_TRUE(handle.is_initialized()); |
72 EXPECT_TRUE(handle.socket()); | 96 EXPECT_TRUE(handle.socket()); |
73 HttpProxyClientSocket* tunnel_socket = | 97 HttpProxyClientSocket* tunnel_socket = |
74 static_cast<HttpProxyClientSocket*>(handle.socket()); | 98 static_cast<HttpProxyClientSocket*>(handle.socket()); |
75 EXPECT_FALSE(tunnel_socket->NeedsRestartWithAuth()); | 99 EXPECT_TRUE(tunnel_socket->IsConnected()); |
76 } | 100 } |
77 | 101 |
78 TEST_F(HttpProxyClientSocketPoolTest, NeedAuth) { | 102 TEST_F(HttpProxyClientSocketPoolTest, NeedAuth) { |
79 MockWrite writes[] = { | 103 MockWrite writes[] = { |
80 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 104 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
81 "Host: host\r\n" | 105 "Host: host\r\n" |
82 "Proxy-Connection: keep-alive\r\n\r\n"), | 106 "Proxy-Connection: keep-alive\r\n\r\n"), |
83 }; | 107 }; |
84 MockRead reads[] = { | 108 MockRead reads[] = { |
85 // No credentials. | 109 // No credentials. |
86 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | 110 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
87 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | 111 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
88 MockRead("Content-Length: 10\r\n\r\n"), | 112 MockRead("Content-Length: 10\r\n\r\n"), |
89 MockRead("0123456789"), | 113 MockRead("0123456789"), |
90 }; | 114 }; |
91 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 115 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
92 arraysize(writes)); | 116 arraysize(writes)); |
93 | 117 |
94 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 118 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
95 MockHttpAuthControllerData auth_data[] = { | |
96 MockHttpAuthControllerData(""), | |
97 }; | |
98 auth_controller_->SetMockAuthControllerData(auth_data, arraysize(auth_data)); | |
99 | 119 |
100 ClientSocketHandle handle; | 120 ClientSocketHandle handle; |
101 TestCompletionCallback callback; | 121 TestCompletionCallback callback; |
102 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 122 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
103 BoundNetLog()); | 123 BoundNetLog()); |
104 EXPECT_EQ(ERR_IO_PENDING, rv); | 124 EXPECT_EQ(ERR_IO_PENDING, rv); |
105 EXPECT_FALSE(handle.is_initialized()); | 125 EXPECT_FALSE(handle.is_initialized()); |
106 EXPECT_FALSE(handle.socket()); | 126 EXPECT_FALSE(handle.socket()); |
107 | 127 |
108 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | 128 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
109 EXPECT_TRUE(handle.is_initialized()); | 129 EXPECT_TRUE(handle.is_initialized()); |
110 EXPECT_TRUE(handle.socket()); | 130 EXPECT_TRUE(handle.socket()); |
111 HttpProxyClientSocket* tunnel_socket = | 131 HttpProxyClientSocket* tunnel_socket = |
112 static_cast<HttpProxyClientSocket*>(handle.socket()); | 132 static_cast<HttpProxyClientSocket*>(handle.socket()); |
113 EXPECT_TRUE(tunnel_socket->NeedsRestartWithAuth()); | 133 EXPECT_FALSE(tunnel_socket->IsConnected()); |
114 } | 134 } |
115 | 135 |
116 TEST_F(HttpProxyClientSocketPoolTest, HaveAuth) { | 136 TEST_F(HttpProxyClientSocketPoolTest, HaveAuth) { |
117 MockWrite writes[] = { | 137 MockWrite writes[] = { |
118 MockWrite(false, | 138 MockWrite(false, |
119 "CONNECT host:80 HTTP/1.1\r\n" | 139 "CONNECT host:80 HTTP/1.1\r\n" |
120 "Host: host\r\n" | 140 "Host: host\r\n" |
121 "Proxy-Connection: keep-alive\r\n" | 141 "Proxy-Connection: keep-alive\r\n" |
122 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 142 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
123 }; | 143 }; |
124 MockRead reads[] = { | 144 MockRead reads[] = { |
125 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), | 145 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
126 }; | 146 }; |
127 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 147 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
128 arraysize(writes)); | 148 arraysize(writes)); |
129 data.set_connect_data(MockConnect(false, 0)); | 149 data.set_connect_data(MockConnect(false, 0)); |
130 | 150 |
131 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 151 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
132 MockHttpAuthControllerData auth_data[] = { | 152 AddAuthToCache(); |
133 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
134 }; | |
135 auth_controller_->SetMockAuthControllerData(auth_data, arraysize(auth_data)); | |
136 | 153 |
137 ClientSocketHandle handle; | 154 ClientSocketHandle handle; |
138 TestCompletionCallback callback; | 155 TestCompletionCallback callback; |
139 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 156 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
140 BoundNetLog()); | 157 BoundNetLog()); |
141 EXPECT_EQ(OK, rv); | 158 EXPECT_EQ(OK, rv); |
142 EXPECT_TRUE(handle.is_initialized()); | 159 EXPECT_TRUE(handle.is_initialized()); |
143 EXPECT_TRUE(handle.socket()); | 160 EXPECT_TRUE(handle.socket()); |
144 HttpProxyClientSocket* tunnel_socket = | 161 HttpProxyClientSocket* tunnel_socket = |
145 static_cast<HttpProxyClientSocket*>(handle.socket()); | 162 static_cast<HttpProxyClientSocket*>(handle.socket()); |
146 EXPECT_FALSE(tunnel_socket->NeedsRestartWithAuth()); | 163 EXPECT_TRUE(tunnel_socket->IsConnected()); |
147 } | 164 } |
148 | 165 |
149 TEST_F(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { | 166 TEST_F(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { |
150 MockWrite writes[] = { | 167 MockWrite writes[] = { |
151 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 168 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
152 "Host: host\r\n" | 169 "Host: host\r\n" |
153 "Proxy-Connection: keep-alive\r\n" | 170 "Proxy-Connection: keep-alive\r\n" |
154 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 171 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
155 }; | 172 }; |
156 MockRead reads[] = { | 173 MockRead reads[] = { |
157 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 174 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
158 }; | 175 }; |
159 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 176 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
160 arraysize(writes)); | 177 arraysize(writes)); |
161 | 178 |
162 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 179 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
163 MockHttpAuthControllerData auth_data[] = { | 180 AddAuthToCache(); |
164 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
165 }; | |
166 auth_controller_->SetMockAuthControllerData(auth_data, arraysize(auth_data)); | |
167 | 181 |
168 ClientSocketHandle handle; | 182 ClientSocketHandle handle; |
169 TestCompletionCallback callback; | 183 TestCompletionCallback callback; |
170 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 184 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
171 BoundNetLog()); | 185 BoundNetLog()); |
172 EXPECT_EQ(ERR_IO_PENDING, rv); | 186 EXPECT_EQ(ERR_IO_PENDING, rv); |
173 EXPECT_FALSE(handle.is_initialized()); | 187 EXPECT_FALSE(handle.is_initialized()); |
174 EXPECT_FALSE(handle.socket()); | 188 EXPECT_FALSE(handle.socket()); |
175 | 189 |
176 EXPECT_EQ(OK, callback.WaitForResult()); | 190 EXPECT_EQ(OK, callback.WaitForResult()); |
177 EXPECT_TRUE(handle.is_initialized()); | 191 EXPECT_TRUE(handle.is_initialized()); |
178 EXPECT_TRUE(handle.socket()); | 192 EXPECT_TRUE(handle.socket()); |
179 HttpProxyClientSocket* tunnel_socket = | 193 HttpProxyClientSocket* tunnel_socket = |
180 static_cast<HttpProxyClientSocket*>(handle.socket()); | 194 static_cast<HttpProxyClientSocket*>(handle.socket()); |
181 EXPECT_FALSE(tunnel_socket->NeedsRestartWithAuth()); | 195 EXPECT_TRUE(tunnel_socket->IsConnected()); |
182 } | 196 } |
183 | 197 |
184 TEST_F(HttpProxyClientSocketPoolTest, TCPError) { | 198 TEST_F(HttpProxyClientSocketPoolTest, TCPError) { |
185 StaticSocketDataProvider data; | 199 StaticSocketDataProvider data; |
186 data.set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); | 200 data.set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); |
187 | 201 |
188 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 202 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
189 | 203 |
190 ClientSocketHandle handle; | 204 ClientSocketHandle handle; |
191 TestCompletionCallback callback; | 205 TestCompletionCallback callback; |
192 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 206 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
193 BoundNetLog()); | 207 BoundNetLog()); |
194 EXPECT_EQ(ERR_IO_PENDING, rv); | 208 EXPECT_EQ(ERR_IO_PENDING, rv); |
195 EXPECT_FALSE(handle.is_initialized()); | 209 EXPECT_FALSE(handle.is_initialized()); |
196 EXPECT_FALSE(handle.socket()); | 210 EXPECT_FALSE(handle.socket()); |
197 | 211 |
198 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); | 212 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
199 EXPECT_FALSE(handle.is_initialized()); | 213 EXPECT_FALSE(handle.is_initialized()); |
200 EXPECT_FALSE(handle.socket()); | 214 EXPECT_FALSE(handle.socket()); |
201 } | 215 } |
202 | 216 |
203 TEST_F(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { | 217 TEST_F(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { |
204 MockWrite writes[] = { | 218 MockWrite writes[] = { |
205 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 219 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
206 "Host: host\r\n" | 220 "Host: host\r\n" |
207 "Proxy-Connection: keep-alive\r\n" | 221 "Proxy-Connection: keep-alive\r\n" |
208 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 222 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
209 }; | 223 }; |
210 MockRead reads[] = { | 224 MockRead reads[] = { |
211 MockRead("HTTP/1.1 200 Conn"), | 225 MockRead("HTTP/1.1 200 Conn"), |
212 MockRead(true, ERR_CONNECTION_CLOSED), | 226 MockRead(true, ERR_CONNECTION_CLOSED), |
213 }; | 227 }; |
214 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 228 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
215 arraysize(writes)); | 229 arraysize(writes)); |
216 | 230 |
217 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 231 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
218 MockHttpAuthControllerData auth_data[] = { | 232 AddAuthToCache(); |
219 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
220 }; | |
221 auth_controller_->SetMockAuthControllerData(auth_data, arraysize(auth_data)); | |
222 | 233 |
223 ClientSocketHandle handle; | 234 ClientSocketHandle handle; |
224 TestCompletionCallback callback; | 235 TestCompletionCallback callback; |
225 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 236 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
226 BoundNetLog()); | 237 BoundNetLog()); |
227 EXPECT_EQ(ERR_IO_PENDING, rv); | 238 EXPECT_EQ(ERR_IO_PENDING, rv); |
228 EXPECT_FALSE(handle.is_initialized()); | 239 EXPECT_FALSE(handle.is_initialized()); |
229 EXPECT_FALSE(handle.socket()); | 240 EXPECT_FALSE(handle.socket()); |
230 | 241 |
231 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); | 242 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
232 EXPECT_FALSE(handle.is_initialized()); | 243 EXPECT_FALSE(handle.is_initialized()); |
233 EXPECT_FALSE(handle.socket()); | 244 EXPECT_FALSE(handle.socket()); |
234 } | 245 } |
235 | 246 |
236 TEST_F(HttpProxyClientSocketPoolTest, TunnelSetupError) { | 247 TEST_F(HttpProxyClientSocketPoolTest, TunnelSetupError) { |
237 MockWrite writes[] = { | 248 MockWrite writes[] = { |
238 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 249 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
239 "Host: host\r\n" | 250 "Host: host\r\n" |
240 "Proxy-Connection: keep-alive\r\n" | 251 "Proxy-Connection: keep-alive\r\n" |
241 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 252 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
242 }; | 253 }; |
243 MockRead reads[] = { | 254 MockRead reads[] = { |
244 MockRead("HTTP/1.1 304 Not Modified\r\n\r\n"), | 255 MockRead("HTTP/1.1 304 Not Modified\r\n\r\n"), |
245 }; | 256 }; |
246 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 257 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
247 arraysize(writes)); | 258 arraysize(writes)); |
248 | 259 |
249 tcp_client_socket_factory_.AddSocketDataProvider(&data); | 260 tcp_client_socket_factory_.AddSocketDataProvider(&data); |
250 MockHttpAuthControllerData auth_data[] = { | 261 AddAuthToCache(); |
251 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
252 }; | |
253 auth_controller_->SetMockAuthControllerData(auth_data, arraysize(auth_data)); | |
254 | 262 |
255 ClientSocketHandle handle; | 263 ClientSocketHandle handle; |
256 TestCompletionCallback callback; | 264 TestCompletionCallback callback; |
257 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, | 265 int rv = handle.Init("a", tunnel_socket_params_, LOW, &callback, pool_, |
258 BoundNetLog()); | 266 BoundNetLog()); |
259 EXPECT_EQ(ERR_IO_PENDING, rv); | 267 EXPECT_EQ(ERR_IO_PENDING, rv); |
260 EXPECT_FALSE(handle.is_initialized()); | 268 EXPECT_FALSE(handle.is_initialized()); |
261 EXPECT_FALSE(handle.socket()); | 269 EXPECT_FALSE(handle.socket()); |
262 | 270 |
263 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); | 271 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); |
264 EXPECT_FALSE(handle.is_initialized()); | 272 EXPECT_FALSE(handle.is_initialized()); |
265 EXPECT_FALSE(handle.socket()); | 273 EXPECT_FALSE(handle.socket()); |
266 } | 274 } |
267 | 275 |
268 // It would be nice to also test the timeouts in HttpProxyClientSocketPool. | 276 // It would be nice to also test the timeouts in HttpProxyClientSocketPool. |
269 | 277 |
270 } // namespace | 278 } // namespace |
271 | 279 |
272 } // namespace net | 280 } // namespace net |
OLD | NEW |