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