| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/websockets/websocket_stream.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <string> | |
| 9 #include <utility> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/compiler_specific.h" | |
| 13 #include "base/memory/scoped_vector.h" | |
| 14 #include "base/metrics/histogram.h" | |
| 15 #include "base/metrics/histogram_samples.h" | |
| 16 #include "base/metrics/statistics_recorder.h" | |
| 17 #include "base/run_loop.h" | |
| 18 #include "base/strings/stringprintf.h" | |
| 19 #include "base/timer/mock_timer.h" | |
| 20 #include "base/timer/timer.h" | |
| 21 #include "net/base/net_errors.h" | |
| 22 #include "net/base/test_data_directory.h" | |
| 23 #include "net/http/http_request_headers.h" | |
| 24 #include "net/http/http_response_headers.h" | |
| 25 #include "net/proxy/proxy_service.h" | |
| 26 #include "net/socket/client_socket_handle.h" | |
| 27 #include "net/socket/socket_test_util.h" | |
| 28 #include "net/test/cert_test_util.h" | |
| 29 #include "net/url_request/url_request_test_util.h" | |
| 30 #include "net/websockets/websocket_basic_handshake_stream.h" | |
| 31 #include "net/websockets/websocket_frame.h" | |
| 32 #include "net/websockets/websocket_stream_create_test_base.h" | |
| 33 #include "net/websockets/websocket_test_util.h" | |
| 34 #include "testing/gtest/include/gtest/gtest.h" | |
| 35 #include "url/gurl.h" | |
| 36 #include "url/origin.h" | |
| 37 | |
| 38 namespace net { | |
| 39 namespace { | |
| 40 | |
| 41 // Simple builder for a DeterministicSocketData object to save repetitive code. | |
| 42 // It always sets the connect data to MockConnect(SYNCHRONOUS, OK), so it cannot | |
| 43 // be used in tests where the connect fails. In practice, those tests never have | |
| 44 // any read/write data and so can't benefit from it anyway. The arrays are not | |
| 45 // copied. It is up to the caller to ensure they stay in scope until the test | |
| 46 // ends. | |
| 47 template <size_t reads_count, size_t writes_count> | |
| 48 scoped_ptr<DeterministicSocketData> BuildSocketData( | |
| 49 MockRead (&reads)[reads_count], | |
| 50 MockWrite (&writes)[writes_count]) { | |
| 51 scoped_ptr<DeterministicSocketData> socket_data( | |
| 52 new DeterministicSocketData(reads, reads_count, writes, writes_count)); | |
| 53 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK)); | |
| 54 socket_data->SetStop(reads_count + writes_count); | |
| 55 return socket_data.Pass(); | |
| 56 } | |
| 57 | |
| 58 // Builder for a DeterministicSocketData that expects nothing. This does not | |
| 59 // set the connect data, so the calling code must do that explicitly. | |
| 60 scoped_ptr<DeterministicSocketData> BuildNullSocketData() { | |
| 61 return make_scoped_ptr(new DeterministicSocketData(NULL, 0, NULL, 0)); | |
| 62 } | |
| 63 | |
| 64 class MockWeakTimer : public base::MockTimer, | |
| 65 public base::SupportsWeakPtr<MockWeakTimer> { | |
| 66 public: | |
| 67 MockWeakTimer(bool retain_user_task, bool is_repeating) | |
| 68 : MockTimer(retain_user_task, is_repeating) {} | |
| 69 }; | |
| 70 | |
| 71 class WebSocketStreamCreateTest : public ::testing::Test, | |
| 72 public WebSocketStreamCreateTestBase { | |
| 73 public: | |
| 74 ~WebSocketStreamCreateTest() override { | |
| 75 // Permit any endpoint locks to be released. | |
| 76 stream_request_.reset(); | |
| 77 stream_.reset(); | |
| 78 base::RunLoop().RunUntilIdle(); | |
| 79 } | |
| 80 | |
| 81 void CreateAndConnectCustomResponse( | |
| 82 const std::string& socket_url, | |
| 83 const std::string& socket_host, | |
| 84 const std::string& socket_path, | |
| 85 const std::vector<std::string>& sub_protocols, | |
| 86 const std::string& origin, | |
| 87 const std::string& extra_request_headers, | |
| 88 const std::string& response_body, | |
| 89 scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) { | |
| 90 url_request_context_host_.SetExpectations( | |
| 91 WebSocketStandardRequest(socket_path, socket_host, origin, | |
| 92 extra_request_headers), | |
| 93 response_body); | |
| 94 CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass()); | |
| 95 } | |
| 96 | |
| 97 // |extra_request_headers| and |extra_response_headers| must end in "\r\n" or | |
| 98 // errors like "Unable to perform synchronous IO while stopped" will occur. | |
| 99 void CreateAndConnectStandard( | |
| 100 const std::string& socket_url, | |
| 101 const std::string& socket_host, | |
| 102 const std::string& socket_path, | |
| 103 const std::vector<std::string>& sub_protocols, | |
| 104 const std::string& origin, | |
| 105 const std::string& extra_request_headers, | |
| 106 const std::string& extra_response_headers, | |
| 107 scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) { | |
| 108 CreateAndConnectCustomResponse( | |
| 109 socket_url, socket_host, socket_path, sub_protocols, origin, | |
| 110 extra_request_headers, | |
| 111 WebSocketStandardResponse(extra_response_headers), timer.Pass()); | |
| 112 } | |
| 113 | |
| 114 void CreateAndConnectRawExpectations( | |
| 115 const std::string& socket_url, | |
| 116 const std::vector<std::string>& sub_protocols, | |
| 117 const std::string& origin, | |
| 118 scoped_ptr<DeterministicSocketData> socket_data, | |
| 119 scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) { | |
| 120 AddRawExpectations(socket_data.Pass()); | |
| 121 CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass()); | |
| 122 } | |
| 123 | |
| 124 // Add additional raw expectations for sockets created before the final one. | |
| 125 void AddRawExpectations(scoped_ptr<DeterministicSocketData> socket_data) { | |
| 126 url_request_context_host_.AddRawExpectations(socket_data.Pass()); | |
| 127 } | |
| 128 }; | |
| 129 | |
| 130 // There are enough tests of the Sec-WebSocket-Extensions header that they | |
| 131 // deserve their own test fixture. | |
| 132 class WebSocketStreamCreateExtensionTest : public WebSocketStreamCreateTest { | |
| 133 public: | |
| 134 // Performs a standard connect, with the value of the Sec-WebSocket-Extensions | |
| 135 // header in the response set to |extensions_header_value|. Runs the event | |
| 136 // loop to allow the connect to complete. | |
| 137 void CreateAndConnectWithExtensions( | |
| 138 const std::string& extensions_header_value) { | |
| 139 CreateAndConnectStandard( | |
| 140 "ws://localhost/testing_path", "localhost", "/testing_path", | |
| 141 NoSubProtocols(), "http://localhost", "", | |
| 142 "Sec-WebSocket-Extensions: " + extensions_header_value + "\r\n"); | |
| 143 WaitUntilConnectDone(); | |
| 144 } | |
| 145 }; | |
| 146 | |
| 147 // Common code to construct expectations for authentication tests that receive | |
| 148 // the auth challenge on one connection and then create a second connection to | |
| 149 // send the authenticated request on. | |
| 150 class CommonAuthTestHelper { | |
| 151 public: | |
| 152 CommonAuthTestHelper() : reads1_(), writes1_(), reads2_(), writes2_() {} | |
| 153 | |
| 154 scoped_ptr<DeterministicSocketData> BuildSocketData1( | |
| 155 const std::string& response) { | |
| 156 request1_ = | |
| 157 WebSocketStandardRequest("/", "localhost", "http://localhost", ""); | |
| 158 writes1_[0] = MockWrite(SYNCHRONOUS, 0, request1_.c_str()); | |
| 159 response1_ = response; | |
| 160 reads1_[0] = MockRead(SYNCHRONOUS, 1, response1_.c_str()); | |
| 161 reads1_[1] = MockRead(SYNCHRONOUS, OK, 2); // Close connection | |
| 162 | |
| 163 return BuildSocketData(reads1_, writes1_); | |
| 164 } | |
| 165 | |
| 166 scoped_ptr<DeterministicSocketData> BuildSocketData2( | |
| 167 const std::string& request, | |
| 168 const std::string& response) { | |
| 169 request2_ = request; | |
| 170 response2_ = response; | |
| 171 writes2_[0] = MockWrite(SYNCHRONOUS, 0, request2_.c_str()); | |
| 172 reads2_[0] = MockRead(SYNCHRONOUS, 1, response2_.c_str()); | |
| 173 return BuildSocketData(reads2_, writes2_); | |
| 174 } | |
| 175 | |
| 176 private: | |
| 177 // These need to be object-scoped since they have to remain valid until all | |
| 178 // socket operations in the test are complete. | |
| 179 std::string request1_; | |
| 180 std::string request2_; | |
| 181 std::string response1_; | |
| 182 std::string response2_; | |
| 183 MockRead reads1_[2]; | |
| 184 MockWrite writes1_[1]; | |
| 185 MockRead reads2_[1]; | |
| 186 MockWrite writes2_[1]; | |
| 187 | |
| 188 DISALLOW_COPY_AND_ASSIGN(CommonAuthTestHelper); | |
| 189 }; | |
| 190 | |
| 191 // Data and methods for BasicAuth tests. | |
| 192 class WebSocketStreamCreateBasicAuthTest : public WebSocketStreamCreateTest { | |
| 193 protected: | |
| 194 void CreateAndConnectAuthHandshake(const std::string& url, | |
| 195 const std::string& base64_user_pass, | |
| 196 const std::string& response2) { | |
| 197 AddRawExpectations(helper_.BuildSocketData1(kUnauthorizedResponse)); | |
| 198 | |
| 199 static const char request2format[] = | |
| 200 "GET / HTTP/1.1\r\n" | |
| 201 "Host: localhost\r\n" | |
| 202 "Connection: Upgrade\r\n" | |
| 203 "Pragma: no-cache\r\n" | |
| 204 "Cache-Control: no-cache\r\n" | |
| 205 "Authorization: Basic %s\r\n" | |
| 206 "Upgrade: websocket\r\n" | |
| 207 "Origin: http://localhost\r\n" | |
| 208 "Sec-WebSocket-Version: 13\r\n" | |
| 209 "User-Agent:\r\n" | |
| 210 "Accept-Encoding: gzip, deflate\r\n" | |
| 211 "Accept-Language: en-us,fr\r\n" | |
| 212 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 213 "Sec-WebSocket-Extensions: permessage-deflate; " | |
| 214 "client_max_window_bits\r\n" | |
| 215 "\r\n"; | |
| 216 const std::string request = | |
| 217 base::StringPrintf(request2format, base64_user_pass.c_str()); | |
| 218 CreateAndConnectRawExpectations( | |
| 219 url, | |
| 220 NoSubProtocols(), | |
| 221 "http://localhost", | |
| 222 helper_.BuildSocketData2(request, response2)); | |
| 223 } | |
| 224 | |
| 225 static const char kUnauthorizedResponse[]; | |
| 226 | |
| 227 CommonAuthTestHelper helper_; | |
| 228 }; | |
| 229 | |
| 230 class WebSocketStreamCreateDigestAuthTest : public WebSocketStreamCreateTest { | |
| 231 protected: | |
| 232 static const char kUnauthorizedResponse[]; | |
| 233 static const char kAuthorizedRequest[]; | |
| 234 | |
| 235 CommonAuthTestHelper helper_; | |
| 236 }; | |
| 237 | |
| 238 const char WebSocketStreamCreateBasicAuthTest::kUnauthorizedResponse[] = | |
| 239 "HTTP/1.1 401 Unauthorized\r\n" | |
| 240 "Content-Length: 0\r\n" | |
| 241 "WWW-Authenticate: Basic realm=\"camelot\"\r\n" | |
| 242 "\r\n"; | |
| 243 | |
| 244 // These negotiation values are borrowed from | |
| 245 // http_auth_handler_digest_unittest.cc. Feel free to come up with new ones if | |
| 246 // you are bored. Only the weakest (no qop) variants of Digest authentication | |
| 247 // can be tested by this method, because the others involve random input. | |
| 248 const char WebSocketStreamCreateDigestAuthTest::kUnauthorizedResponse[] = | |
| 249 "HTTP/1.1 401 Unauthorized\r\n" | |
| 250 "Content-Length: 0\r\n" | |
| 251 "WWW-Authenticate: Digest realm=\"Oblivion\", nonce=\"nonce-value\"\r\n" | |
| 252 "\r\n"; | |
| 253 | |
| 254 const char WebSocketStreamCreateDigestAuthTest::kAuthorizedRequest[] = | |
| 255 "GET / HTTP/1.1\r\n" | |
| 256 "Host: localhost\r\n" | |
| 257 "Connection: Upgrade\r\n" | |
| 258 "Pragma: no-cache\r\n" | |
| 259 "Cache-Control: no-cache\r\n" | |
| 260 "Authorization: Digest username=\"FooBar\", realm=\"Oblivion\", " | |
| 261 "nonce=\"nonce-value\", uri=\"/\", " | |
| 262 "response=\"f72ff54ebde2f928860f806ec04acd1b\"\r\n" | |
| 263 "Upgrade: websocket\r\n" | |
| 264 "Origin: http://localhost\r\n" | |
| 265 "Sec-WebSocket-Version: 13\r\n" | |
| 266 "User-Agent:\r\n" | |
| 267 "Accept-Encoding: gzip, deflate\r\n" | |
| 268 "Accept-Language: en-us,fr\r\n" | |
| 269 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 270 "Sec-WebSocket-Extensions: permessage-deflate; " | |
| 271 "client_max_window_bits\r\n" | |
| 272 "\r\n"; | |
| 273 | |
| 274 class WebSocketStreamCreateUMATest : public ::testing::Test { | |
| 275 public: | |
| 276 // This enum should match with the enum in Delegate in websocket_stream.cc. | |
| 277 enum HandshakeResult { | |
| 278 INCOMPLETE, | |
| 279 CONNECTED, | |
| 280 FAILED, | |
| 281 NUM_HANDSHAKE_RESULT_TYPES, | |
| 282 }; | |
| 283 | |
| 284 class StreamCreation : public WebSocketStreamCreateTest { | |
| 285 void TestBody() override {} | |
| 286 }; | |
| 287 | |
| 288 scoped_ptr<base::HistogramSamples> GetSamples(const std::string& name) { | |
| 289 base::HistogramBase* histogram = | |
| 290 base::StatisticsRecorder::FindHistogram(name); | |
| 291 return histogram ? histogram->SnapshotSamples() | |
| 292 : scoped_ptr<base::HistogramSamples>(); | |
| 293 } | |
| 294 }; | |
| 295 | |
| 296 // Confirm that the basic case works as expected. | |
| 297 TEST_F(WebSocketStreamCreateTest, SimpleSuccess) { | |
| 298 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 299 NoSubProtocols(), "http://localhost", "", ""); | |
| 300 EXPECT_FALSE(request_info_); | |
| 301 EXPECT_FALSE(response_info_); | |
| 302 WaitUntilConnectDone(); | |
| 303 EXPECT_FALSE(has_failed()); | |
| 304 EXPECT_TRUE(stream_); | |
| 305 EXPECT_TRUE(request_info_); | |
| 306 EXPECT_TRUE(response_info_); | |
| 307 } | |
| 308 | |
| 309 TEST_F(WebSocketStreamCreateTest, HandshakeInfo) { | |
| 310 static const char kResponse[] = | |
| 311 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 312 "Upgrade: websocket\r\n" | |
| 313 "Connection: Upgrade\r\n" | |
| 314 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 315 "foo: bar, baz\r\n" | |
| 316 "hoge: fuga\r\n" | |
| 317 "hoge: piyo\r\n" | |
| 318 "\r\n"; | |
| 319 | |
| 320 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 321 NoSubProtocols(), "http://localhost", "", | |
| 322 kResponse); | |
| 323 EXPECT_FALSE(request_info_); | |
| 324 EXPECT_FALSE(response_info_); | |
| 325 WaitUntilConnectDone(); | |
| 326 EXPECT_TRUE(stream_); | |
| 327 ASSERT_TRUE(request_info_); | |
| 328 ASSERT_TRUE(response_info_); | |
| 329 std::vector<HeaderKeyValuePair> request_headers = | |
| 330 RequestHeadersToVector(request_info_->headers); | |
| 331 // We examine the contents of request_info_ and response_info_ | |
| 332 // mainly only in this test case. | |
| 333 EXPECT_EQ(GURL("ws://localhost/"), request_info_->url); | |
| 334 EXPECT_EQ(GURL("ws://localhost/"), response_info_->url); | |
| 335 EXPECT_EQ(101, response_info_->status_code); | |
| 336 EXPECT_EQ("Switching Protocols", response_info_->status_text); | |
| 337 ASSERT_EQ(12u, request_headers.size()); | |
| 338 EXPECT_EQ(HeaderKeyValuePair("Host", "localhost"), request_headers[0]); | |
| 339 EXPECT_EQ(HeaderKeyValuePair("Connection", "Upgrade"), request_headers[1]); | |
| 340 EXPECT_EQ(HeaderKeyValuePair("Pragma", "no-cache"), request_headers[2]); | |
| 341 EXPECT_EQ(HeaderKeyValuePair("Cache-Control", "no-cache"), | |
| 342 request_headers[3]); | |
| 343 EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), request_headers[4]); | |
| 344 EXPECT_EQ(HeaderKeyValuePair("Origin", "http://localhost"), | |
| 345 request_headers[5]); | |
| 346 EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Version", "13"), | |
| 347 request_headers[6]); | |
| 348 EXPECT_EQ(HeaderKeyValuePair("User-Agent", ""), request_headers[7]); | |
| 349 EXPECT_EQ(HeaderKeyValuePair("Accept-Encoding", "gzip, deflate"), | |
| 350 request_headers[8]); | |
| 351 EXPECT_EQ(HeaderKeyValuePair("Accept-Language", "en-us,fr"), | |
| 352 request_headers[9]); | |
| 353 EXPECT_EQ("Sec-WebSocket-Key", request_headers[10].first); | |
| 354 EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Extensions", | |
| 355 "permessage-deflate; client_max_window_bits"), | |
| 356 request_headers[11]); | |
| 357 | |
| 358 std::vector<HeaderKeyValuePair> response_headers = | |
| 359 ResponseHeadersToVector(*response_info_->headers.get()); | |
| 360 ASSERT_EQ(6u, response_headers.size()); | |
| 361 // Sort the headers for ease of verification. | |
| 362 std::sort(response_headers.begin(), response_headers.end()); | |
| 363 | |
| 364 EXPECT_EQ(HeaderKeyValuePair("Connection", "Upgrade"), response_headers[0]); | |
| 365 EXPECT_EQ("Sec-WebSocket-Accept", response_headers[1].first); | |
| 366 EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), response_headers[2]); | |
| 367 EXPECT_EQ(HeaderKeyValuePair("foo", "bar, baz"), response_headers[3]); | |
| 368 EXPECT_EQ(HeaderKeyValuePair("hoge", "fuga"), response_headers[4]); | |
| 369 EXPECT_EQ(HeaderKeyValuePair("hoge", "piyo"), response_headers[5]); | |
| 370 } | |
| 371 | |
| 372 // Confirm that the stream isn't established until the message loop runs. | |
| 373 TEST_F(WebSocketStreamCreateTest, NeedsToRunLoop) { | |
| 374 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 375 NoSubProtocols(), "http://localhost", "", ""); | |
| 376 EXPECT_FALSE(has_failed()); | |
| 377 EXPECT_FALSE(stream_); | |
| 378 } | |
| 379 | |
| 380 // Check the path is used. | |
| 381 TEST_F(WebSocketStreamCreateTest, PathIsUsed) { | |
| 382 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 383 "/testing_path", NoSubProtocols(), | |
| 384 "http://localhost", "", ""); | |
| 385 WaitUntilConnectDone(); | |
| 386 EXPECT_FALSE(has_failed()); | |
| 387 EXPECT_TRUE(stream_); | |
| 388 } | |
| 389 | |
| 390 // Check that the origin is used. | |
| 391 TEST_F(WebSocketStreamCreateTest, OriginIsUsed) { | |
| 392 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 393 "/testing_path", NoSubProtocols(), | |
| 394 "http://google.com", "", ""); | |
| 395 WaitUntilConnectDone(); | |
| 396 EXPECT_FALSE(has_failed()); | |
| 397 EXPECT_TRUE(stream_); | |
| 398 } | |
| 399 | |
| 400 // Check that sub-protocols are sent and parsed. | |
| 401 TEST_F(WebSocketStreamCreateTest, SubProtocolIsUsed) { | |
| 402 std::vector<std::string> sub_protocols; | |
| 403 sub_protocols.push_back("chatv11.chromium.org"); | |
| 404 sub_protocols.push_back("chatv20.chromium.org"); | |
| 405 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 406 "/testing_path", sub_protocols, "http://google.com", | |
| 407 "Sec-WebSocket-Protocol: chatv11.chromium.org, " | |
| 408 "chatv20.chromium.org\r\n", | |
| 409 "Sec-WebSocket-Protocol: chatv20.chromium.org\r\n"); | |
| 410 WaitUntilConnectDone(); | |
| 411 EXPECT_TRUE(stream_); | |
| 412 EXPECT_FALSE(has_failed()); | |
| 413 EXPECT_EQ("chatv20.chromium.org", stream_->GetSubProtocol()); | |
| 414 } | |
| 415 | |
| 416 // Unsolicited sub-protocols are rejected. | |
| 417 TEST_F(WebSocketStreamCreateTest, UnsolicitedSubProtocol) { | |
| 418 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 419 "/testing_path", NoSubProtocols(), | |
| 420 "http://google.com", "", | |
| 421 "Sec-WebSocket-Protocol: chatv20.chromium.org\r\n"); | |
| 422 WaitUntilConnectDone(); | |
| 423 EXPECT_FALSE(stream_); | |
| 424 EXPECT_TRUE(has_failed()); | |
| 425 EXPECT_EQ("Error during WebSocket handshake: " | |
| 426 "Response must not include 'Sec-WebSocket-Protocol' header " | |
| 427 "if not present in request: chatv20.chromium.org", | |
| 428 failure_message()); | |
| 429 } | |
| 430 | |
| 431 // Missing sub-protocol response is rejected. | |
| 432 TEST_F(WebSocketStreamCreateTest, UnacceptedSubProtocol) { | |
| 433 std::vector<std::string> sub_protocols; | |
| 434 sub_protocols.push_back("chat.example.com"); | |
| 435 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 436 "/testing_path", sub_protocols, "http://localhost", | |
| 437 "Sec-WebSocket-Protocol: chat.example.com\r\n", ""); | |
| 438 WaitUntilConnectDone(); | |
| 439 EXPECT_FALSE(stream_); | |
| 440 EXPECT_TRUE(has_failed()); | |
| 441 EXPECT_EQ("Error during WebSocket handshake: " | |
| 442 "Sent non-empty 'Sec-WebSocket-Protocol' header " | |
| 443 "but no response was received", | |
| 444 failure_message()); | |
| 445 } | |
| 446 | |
| 447 // Only one sub-protocol can be accepted. | |
| 448 TEST_F(WebSocketStreamCreateTest, MultipleSubProtocolsInResponse) { | |
| 449 std::vector<std::string> sub_protocols; | |
| 450 sub_protocols.push_back("chatv11.chromium.org"); | |
| 451 sub_protocols.push_back("chatv20.chromium.org"); | |
| 452 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 453 "/testing_path", sub_protocols, "http://google.com", | |
| 454 "Sec-WebSocket-Protocol: chatv11.chromium.org, " | |
| 455 "chatv20.chromium.org\r\n", | |
| 456 "Sec-WebSocket-Protocol: chatv11.chromium.org, " | |
| 457 "chatv20.chromium.org\r\n"); | |
| 458 WaitUntilConnectDone(); | |
| 459 EXPECT_FALSE(stream_); | |
| 460 EXPECT_TRUE(has_failed()); | |
| 461 EXPECT_EQ("Error during WebSocket handshake: " | |
| 462 "'Sec-WebSocket-Protocol' header must not appear " | |
| 463 "more than once in a response", | |
| 464 failure_message()); | |
| 465 } | |
| 466 | |
| 467 // Unmatched sub-protocol should be rejected. | |
| 468 TEST_F(WebSocketStreamCreateTest, UnmatchedSubProtocolInResponse) { | |
| 469 std::vector<std::string> sub_protocols; | |
| 470 sub_protocols.push_back("chatv11.chromium.org"); | |
| 471 sub_protocols.push_back("chatv20.chromium.org"); | |
| 472 CreateAndConnectStandard("ws://localhost/testing_path", "localhost", | |
| 473 "/testing_path", sub_protocols, "http://google.com", | |
| 474 "Sec-WebSocket-Protocol: chatv11.chromium.org, " | |
| 475 "chatv20.chromium.org\r\n", | |
| 476 "Sec-WebSocket-Protocol: chatv21.chromium.org\r\n"); | |
| 477 WaitUntilConnectDone(); | |
| 478 EXPECT_FALSE(stream_); | |
| 479 EXPECT_TRUE(has_failed()); | |
| 480 EXPECT_EQ("Error during WebSocket handshake: " | |
| 481 "'Sec-WebSocket-Protocol' header value 'chatv21.chromium.org' " | |
| 482 "in response does not match any of sent values", | |
| 483 failure_message()); | |
| 484 } | |
| 485 | |
| 486 // permessage-deflate extension basic success case. | |
| 487 TEST_F(WebSocketStreamCreateExtensionTest, PerMessageDeflateSuccess) { | |
| 488 CreateAndConnectWithExtensions("permessage-deflate"); | |
| 489 EXPECT_TRUE(stream_); | |
| 490 EXPECT_FALSE(has_failed()); | |
| 491 } | |
| 492 | |
| 493 // permessage-deflate extensions success with all parameters. | |
| 494 TEST_F(WebSocketStreamCreateExtensionTest, PerMessageDeflateParamsSuccess) { | |
| 495 CreateAndConnectWithExtensions( | |
| 496 "permessage-deflate; client_no_context_takeover; " | |
| 497 "server_max_window_bits=11; client_max_window_bits=13; " | |
| 498 "server_no_context_takeover"); | |
| 499 EXPECT_TRUE(stream_); | |
| 500 EXPECT_FALSE(has_failed()); | |
| 501 } | |
| 502 | |
| 503 // Verify that incoming messages are actually decompressed with | |
| 504 // permessage-deflate enabled. | |
| 505 TEST_F(WebSocketStreamCreateExtensionTest, PerMessageDeflateInflates) { | |
| 506 CreateAndConnectCustomResponse( | |
| 507 "ws://localhost/testing_path", "localhost", "/testing_path", | |
| 508 NoSubProtocols(), "http://localhost", "", | |
| 509 WebSocketStandardResponse( | |
| 510 "Sec-WebSocket-Extensions: permessage-deflate\r\n") + | |
| 511 std::string( | |
| 512 "\xc1\x07" // WebSocket header (FIN + RSV1, Text payload 7 bytes) | |
| 513 "\xf2\x48\xcd\xc9\xc9\x07\x00", // "Hello" DEFLATE compressed | |
| 514 9)); | |
| 515 WaitUntilConnectDone(); | |
| 516 | |
| 517 ASSERT_TRUE(stream_); | |
| 518 ScopedVector<WebSocketFrame> frames; | |
| 519 CompletionCallback callback; | |
| 520 ASSERT_EQ(OK, stream_->ReadFrames(&frames, callback)); | |
| 521 ASSERT_EQ(1U, frames.size()); | |
| 522 ASSERT_EQ(5U, frames[0]->header.payload_length); | |
| 523 EXPECT_EQ("Hello", std::string(frames[0]->data->data(), 5)); | |
| 524 } | |
| 525 | |
| 526 // Unknown extension in the response is rejected | |
| 527 TEST_F(WebSocketStreamCreateExtensionTest, UnknownExtension) { | |
| 528 CreateAndConnectWithExtensions("x-unknown-extension"); | |
| 529 EXPECT_FALSE(stream_); | |
| 530 EXPECT_TRUE(has_failed()); | |
| 531 EXPECT_EQ("Error during WebSocket handshake: " | |
| 532 "Found an unsupported extension 'x-unknown-extension' " | |
| 533 "in 'Sec-WebSocket-Extensions' header", | |
| 534 failure_message()); | |
| 535 } | |
| 536 | |
| 537 // Malformed extensions are rejected (this file does not cover all possible | |
| 538 // parse failures, as the parser is covered thoroughly by its own unit tests). | |
| 539 TEST_F(WebSocketStreamCreateExtensionTest, MalformedExtension) { | |
| 540 CreateAndConnectWithExtensions(";"); | |
| 541 EXPECT_FALSE(stream_); | |
| 542 EXPECT_TRUE(has_failed()); | |
| 543 EXPECT_EQ( | |
| 544 "Error during WebSocket handshake: 'Sec-WebSocket-Extensions' header " | |
| 545 "value is rejected by the parser: ;", | |
| 546 failure_message()); | |
| 547 } | |
| 548 | |
| 549 // The permessage-deflate extension may only be specified once. | |
| 550 TEST_F(WebSocketStreamCreateExtensionTest, OnlyOnePerMessageDeflateAllowed) { | |
| 551 CreateAndConnectWithExtensions( | |
| 552 "permessage-deflate, permessage-deflate; client_max_window_bits=10"); | |
| 553 EXPECT_FALSE(stream_); | |
| 554 EXPECT_TRUE(has_failed()); | |
| 555 EXPECT_EQ( | |
| 556 "Error during WebSocket handshake: " | |
| 557 "Received duplicate permessage-deflate response", | |
| 558 failure_message()); | |
| 559 } | |
| 560 | |
| 561 // permessage-deflate parameters may not be duplicated. | |
| 562 TEST_F(WebSocketStreamCreateExtensionTest, NoDuplicateParameters) { | |
| 563 CreateAndConnectWithExtensions( | |
| 564 "permessage-deflate; client_no_context_takeover; " | |
| 565 "client_no_context_takeover"); | |
| 566 EXPECT_FALSE(stream_); | |
| 567 EXPECT_TRUE(has_failed()); | |
| 568 EXPECT_EQ( | |
| 569 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 570 "Received duplicate permessage-deflate extension parameter " | |
| 571 "client_no_context_takeover", | |
| 572 failure_message()); | |
| 573 } | |
| 574 | |
| 575 // permessage-deflate parameters must start with "client_" or "server_" | |
| 576 TEST_F(WebSocketStreamCreateExtensionTest, BadParameterPrefix) { | |
| 577 CreateAndConnectWithExtensions( | |
| 578 "permessage-deflate; absurd_no_context_takeover"); | |
| 579 EXPECT_FALSE(stream_); | |
| 580 EXPECT_TRUE(has_failed()); | |
| 581 EXPECT_EQ( | |
| 582 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 583 "Received an unexpected permessage-deflate extension parameter", | |
| 584 failure_message()); | |
| 585 } | |
| 586 | |
| 587 // permessage-deflate parameters must be either *_no_context_takeover or | |
| 588 // *_max_window_bits | |
| 589 TEST_F(WebSocketStreamCreateExtensionTest, BadParameterSuffix) { | |
| 590 CreateAndConnectWithExtensions( | |
| 591 "permessage-deflate; client_max_content_bits=5"); | |
| 592 EXPECT_FALSE(stream_); | |
| 593 EXPECT_TRUE(has_failed()); | |
| 594 EXPECT_EQ( | |
| 595 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 596 "Received an unexpected permessage-deflate extension parameter", | |
| 597 failure_message()); | |
| 598 } | |
| 599 | |
| 600 // *_no_context_takeover parameters must not have an argument | |
| 601 TEST_F(WebSocketStreamCreateExtensionTest, BadParameterValue) { | |
| 602 CreateAndConnectWithExtensions( | |
| 603 "permessage-deflate; client_no_context_takeover=true"); | |
| 604 EXPECT_FALSE(stream_); | |
| 605 EXPECT_TRUE(has_failed()); | |
| 606 EXPECT_EQ( | |
| 607 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 608 "Received invalid client_no_context_takeover parameter", | |
| 609 failure_message()); | |
| 610 } | |
| 611 | |
| 612 // *_max_window_bits must have an argument | |
| 613 TEST_F(WebSocketStreamCreateExtensionTest, NoMaxWindowBitsArgument) { | |
| 614 CreateAndConnectWithExtensions("permessage-deflate; client_max_window_bits"); | |
| 615 EXPECT_FALSE(stream_); | |
| 616 EXPECT_TRUE(has_failed()); | |
| 617 EXPECT_EQ( | |
| 618 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 619 "client_max_window_bits must have value", | |
| 620 failure_message()); | |
| 621 } | |
| 622 | |
| 623 // *_max_window_bits must be an integer | |
| 624 TEST_F(WebSocketStreamCreateExtensionTest, MaxWindowBitsValueInteger) { | |
| 625 CreateAndConnectWithExtensions( | |
| 626 "permessage-deflate; server_max_window_bits=banana"); | |
| 627 EXPECT_FALSE(stream_); | |
| 628 EXPECT_TRUE(has_failed()); | |
| 629 EXPECT_EQ( | |
| 630 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 631 "Received invalid server_max_window_bits parameter", | |
| 632 failure_message()); | |
| 633 } | |
| 634 | |
| 635 // *_max_window_bits must be >= 8 | |
| 636 TEST_F(WebSocketStreamCreateExtensionTest, MaxWindowBitsValueTooSmall) { | |
| 637 CreateAndConnectWithExtensions( | |
| 638 "permessage-deflate; server_max_window_bits=7"); | |
| 639 EXPECT_FALSE(stream_); | |
| 640 EXPECT_TRUE(has_failed()); | |
| 641 EXPECT_EQ( | |
| 642 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 643 "Received invalid server_max_window_bits parameter", | |
| 644 failure_message()); | |
| 645 } | |
| 646 | |
| 647 // *_max_window_bits must be <= 15 | |
| 648 TEST_F(WebSocketStreamCreateExtensionTest, MaxWindowBitsValueTooBig) { | |
| 649 CreateAndConnectWithExtensions( | |
| 650 "permessage-deflate; client_max_window_bits=16"); | |
| 651 EXPECT_FALSE(stream_); | |
| 652 EXPECT_TRUE(has_failed()); | |
| 653 EXPECT_EQ( | |
| 654 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 655 "Received invalid client_max_window_bits parameter", | |
| 656 failure_message()); | |
| 657 } | |
| 658 | |
| 659 // *_max_window_bits must not start with 0 | |
| 660 TEST_F(WebSocketStreamCreateExtensionTest, MaxWindowBitsValueStartsWithZero) { | |
| 661 CreateAndConnectWithExtensions( | |
| 662 "permessage-deflate; client_max_window_bits=08"); | |
| 663 EXPECT_FALSE(stream_); | |
| 664 EXPECT_TRUE(has_failed()); | |
| 665 EXPECT_EQ( | |
| 666 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 667 "Received invalid client_max_window_bits parameter", | |
| 668 failure_message()); | |
| 669 } | |
| 670 | |
| 671 // *_max_window_bits must not start with + | |
| 672 TEST_F(WebSocketStreamCreateExtensionTest, MaxWindowBitsValueStartsWithPlus) { | |
| 673 CreateAndConnectWithExtensions( | |
| 674 "permessage-deflate; server_max_window_bits=+9"); | |
| 675 EXPECT_FALSE(stream_); | |
| 676 EXPECT_TRUE(has_failed()); | |
| 677 EXPECT_EQ( | |
| 678 "Error during WebSocket handshake: Error in permessage-deflate: " | |
| 679 "Received invalid server_max_window_bits parameter", | |
| 680 failure_message()); | |
| 681 } | |
| 682 | |
| 683 // TODO(ricea): Check that WebSocketDeflateStream is initialised with the | |
| 684 // arguments from the server. This is difficult because the data written to the | |
| 685 // socket is randomly masked. | |
| 686 | |
| 687 // Additional Sec-WebSocket-Accept headers should be rejected. | |
| 688 TEST_F(WebSocketStreamCreateTest, DoubleAccept) { | |
| 689 CreateAndConnectStandard( | |
| 690 "ws://localhost/", "localhost", "/", NoSubProtocols(), "http://localhost", | |
| 691 "", "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"); | |
| 692 WaitUntilConnectDone(); | |
| 693 EXPECT_FALSE(stream_); | |
| 694 EXPECT_TRUE(has_failed()); | |
| 695 EXPECT_EQ("Error during WebSocket handshake: " | |
| 696 "'Sec-WebSocket-Accept' header must not appear " | |
| 697 "more than once in a response", | |
| 698 failure_message()); | |
| 699 } | |
| 700 | |
| 701 // Response code 200 must be rejected. | |
| 702 TEST_F(WebSocketStreamCreateTest, InvalidStatusCode) { | |
| 703 static const char kInvalidStatusCodeResponse[] = | |
| 704 "HTTP/1.1 200 OK\r\n" | |
| 705 "Upgrade: websocket\r\n" | |
| 706 "Connection: Upgrade\r\n" | |
| 707 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 708 "\r\n"; | |
| 709 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 710 NoSubProtocols(), "http://localhost", "", | |
| 711 kInvalidStatusCodeResponse); | |
| 712 WaitUntilConnectDone(); | |
| 713 EXPECT_TRUE(has_failed()); | |
| 714 EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 200", | |
| 715 failure_message()); | |
| 716 } | |
| 717 | |
| 718 // Redirects are not followed (according to the WHATWG WebSocket API, which | |
| 719 // overrides RFC6455 for browser applications). | |
| 720 TEST_F(WebSocketStreamCreateTest, RedirectsRejected) { | |
| 721 static const char kRedirectResponse[] = | |
| 722 "HTTP/1.1 302 Moved Temporarily\r\n" | |
| 723 "Content-Type: text/html\r\n" | |
| 724 "Content-Length: 34\r\n" | |
| 725 "Connection: keep-alive\r\n" | |
| 726 "Location: ws://localhost/other\r\n" | |
| 727 "\r\n" | |
| 728 "<title>Moved</title><h1>Moved</h1>"; | |
| 729 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 730 NoSubProtocols(), "http://localhost", "", | |
| 731 kRedirectResponse); | |
| 732 WaitUntilConnectDone(); | |
| 733 EXPECT_TRUE(has_failed()); | |
| 734 EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 302", | |
| 735 failure_message()); | |
| 736 } | |
| 737 | |
| 738 // Malformed responses should be rejected. HttpStreamParser will accept just | |
| 739 // about any garbage in the middle of the headers. To make it give up, the junk | |
| 740 // has to be at the start of the response. Even then, it just gets treated as an | |
| 741 // HTTP/0.9 response. | |
| 742 TEST_F(WebSocketStreamCreateTest, MalformedResponse) { | |
| 743 static const char kMalformedResponse[] = | |
| 744 "220 mx.google.com ESMTP\r\n" | |
| 745 "HTTP/1.1 101 OK\r\n" | |
| 746 "Upgrade: websocket\r\n" | |
| 747 "Connection: Upgrade\r\n" | |
| 748 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 749 "\r\n"; | |
| 750 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 751 NoSubProtocols(), "http://localhost", "", | |
| 752 kMalformedResponse); | |
| 753 WaitUntilConnectDone(); | |
| 754 EXPECT_TRUE(has_failed()); | |
| 755 EXPECT_EQ("Error during WebSocket handshake: Invalid status line", | |
| 756 failure_message()); | |
| 757 } | |
| 758 | |
| 759 // Upgrade header must be present. | |
| 760 TEST_F(WebSocketStreamCreateTest, MissingUpgradeHeader) { | |
| 761 static const char kMissingUpgradeResponse[] = | |
| 762 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 763 "Connection: Upgrade\r\n" | |
| 764 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 765 "\r\n"; | |
| 766 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 767 NoSubProtocols(), "http://localhost", "", | |
| 768 kMissingUpgradeResponse); | |
| 769 WaitUntilConnectDone(); | |
| 770 EXPECT_TRUE(has_failed()); | |
| 771 EXPECT_EQ("Error during WebSocket handshake: 'Upgrade' header is missing", | |
| 772 failure_message()); | |
| 773 } | |
| 774 | |
| 775 // There must only be one upgrade header. | |
| 776 TEST_F(WebSocketStreamCreateTest, DoubleUpgradeHeader) { | |
| 777 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 778 NoSubProtocols(), "http://localhost", "", | |
| 779 "Upgrade: HTTP/2.0\r\n"); | |
| 780 WaitUntilConnectDone(); | |
| 781 EXPECT_TRUE(has_failed()); | |
| 782 EXPECT_EQ("Error during WebSocket handshake: " | |
| 783 "'Upgrade' header must not appear more than once in a response", | |
| 784 failure_message()); | |
| 785 } | |
| 786 | |
| 787 // There must only be one correct upgrade header. | |
| 788 TEST_F(WebSocketStreamCreateTest, IncorrectUpgradeHeader) { | |
| 789 static const char kMissingUpgradeResponse[] = | |
| 790 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 791 "Connection: Upgrade\r\n" | |
| 792 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 793 "Upgrade: hogefuga\r\n" | |
| 794 "\r\n"; | |
| 795 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 796 NoSubProtocols(), "http://localhost", "", | |
| 797 kMissingUpgradeResponse); | |
| 798 WaitUntilConnectDone(); | |
| 799 EXPECT_TRUE(has_failed()); | |
| 800 EXPECT_EQ("Error during WebSocket handshake: " | |
| 801 "'Upgrade' header value is not 'WebSocket': hogefuga", | |
| 802 failure_message()); | |
| 803 } | |
| 804 | |
| 805 // Connection header must be present. | |
| 806 TEST_F(WebSocketStreamCreateTest, MissingConnectionHeader) { | |
| 807 static const char kMissingConnectionResponse[] = | |
| 808 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 809 "Upgrade: websocket\r\n" | |
| 810 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 811 "\r\n"; | |
| 812 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 813 NoSubProtocols(), "http://localhost", "", | |
| 814 kMissingConnectionResponse); | |
| 815 WaitUntilConnectDone(); | |
| 816 EXPECT_TRUE(has_failed()); | |
| 817 EXPECT_EQ("Error during WebSocket handshake: " | |
| 818 "'Connection' header is missing", | |
| 819 failure_message()); | |
| 820 } | |
| 821 | |
| 822 // Connection header must contain "Upgrade". | |
| 823 TEST_F(WebSocketStreamCreateTest, IncorrectConnectionHeader) { | |
| 824 static const char kMissingConnectionResponse[] = | |
| 825 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 826 "Upgrade: websocket\r\n" | |
| 827 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 828 "Connection: hogefuga\r\n" | |
| 829 "\r\n"; | |
| 830 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 831 NoSubProtocols(), "http://localhost", "", | |
| 832 kMissingConnectionResponse); | |
| 833 WaitUntilConnectDone(); | |
| 834 EXPECT_TRUE(has_failed()); | |
| 835 EXPECT_EQ("Error during WebSocket handshake: " | |
| 836 "'Connection' header value must contain 'Upgrade'", | |
| 837 failure_message()); | |
| 838 } | |
| 839 | |
| 840 // Connection header is permitted to contain other tokens. | |
| 841 TEST_F(WebSocketStreamCreateTest, AdditionalTokenInConnectionHeader) { | |
| 842 static const char kAdditionalConnectionTokenResponse[] = | |
| 843 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 844 "Upgrade: websocket\r\n" | |
| 845 "Connection: Upgrade, Keep-Alive\r\n" | |
| 846 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 847 "\r\n"; | |
| 848 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 849 NoSubProtocols(), "http://localhost", "", | |
| 850 kAdditionalConnectionTokenResponse); | |
| 851 WaitUntilConnectDone(); | |
| 852 EXPECT_FALSE(has_failed()); | |
| 853 EXPECT_TRUE(stream_); | |
| 854 } | |
| 855 | |
| 856 // Sec-WebSocket-Accept header must be present. | |
| 857 TEST_F(WebSocketStreamCreateTest, MissingSecWebSocketAccept) { | |
| 858 static const char kMissingAcceptResponse[] = | |
| 859 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 860 "Upgrade: websocket\r\n" | |
| 861 "Connection: Upgrade\r\n" | |
| 862 "\r\n"; | |
| 863 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 864 NoSubProtocols(), "http://localhost", "", | |
| 865 kMissingAcceptResponse); | |
| 866 WaitUntilConnectDone(); | |
| 867 EXPECT_TRUE(has_failed()); | |
| 868 EXPECT_EQ("Error during WebSocket handshake: " | |
| 869 "'Sec-WebSocket-Accept' header is missing", | |
| 870 failure_message()); | |
| 871 } | |
| 872 | |
| 873 // Sec-WebSocket-Accept header must match the key that was sent. | |
| 874 TEST_F(WebSocketStreamCreateTest, WrongSecWebSocketAccept) { | |
| 875 static const char kIncorrectAcceptResponse[] = | |
| 876 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 877 "Upgrade: websocket\r\n" | |
| 878 "Connection: Upgrade\r\n" | |
| 879 "Sec-WebSocket-Accept: x/byyPZ2tOFvJCGkkugcKvqhhPk=\r\n" | |
| 880 "\r\n"; | |
| 881 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 882 NoSubProtocols(), "http://localhost", "", | |
| 883 kIncorrectAcceptResponse); | |
| 884 WaitUntilConnectDone(); | |
| 885 EXPECT_TRUE(has_failed()); | |
| 886 EXPECT_EQ("Error during WebSocket handshake: " | |
| 887 "Incorrect 'Sec-WebSocket-Accept' header value", | |
| 888 failure_message()); | |
| 889 } | |
| 890 | |
| 891 // Cancellation works. | |
| 892 TEST_F(WebSocketStreamCreateTest, Cancellation) { | |
| 893 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 894 NoSubProtocols(), "http://localhost", "", ""); | |
| 895 stream_request_.reset(); | |
| 896 // WaitUntilConnectDone doesn't work in this case. | |
| 897 base::RunLoop().RunUntilIdle(); | |
| 898 EXPECT_FALSE(has_failed()); | |
| 899 EXPECT_FALSE(stream_); | |
| 900 EXPECT_FALSE(request_info_); | |
| 901 EXPECT_FALSE(response_info_); | |
| 902 } | |
| 903 | |
| 904 // Connect failure must look just like negotiation failure. | |
| 905 TEST_F(WebSocketStreamCreateTest, ConnectionFailure) { | |
| 906 scoped_ptr<DeterministicSocketData> socket_data(BuildNullSocketData()); | |
| 907 socket_data->set_connect_data( | |
| 908 MockConnect(SYNCHRONOUS, ERR_CONNECTION_REFUSED)); | |
| 909 CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(), | |
| 910 "http://localhost", socket_data.Pass()); | |
| 911 WaitUntilConnectDone(); | |
| 912 EXPECT_TRUE(has_failed()); | |
| 913 EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_REFUSED", | |
| 914 failure_message()); | |
| 915 EXPECT_FALSE(request_info_); | |
| 916 EXPECT_FALSE(response_info_); | |
| 917 } | |
| 918 | |
| 919 // Connect timeout must look just like any other failure. | |
| 920 TEST_F(WebSocketStreamCreateTest, ConnectionTimeout) { | |
| 921 scoped_ptr<DeterministicSocketData> socket_data(BuildNullSocketData()); | |
| 922 socket_data->set_connect_data( | |
| 923 MockConnect(ASYNC, ERR_CONNECTION_TIMED_OUT)); | |
| 924 CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(), | |
| 925 "http://localhost", socket_data.Pass()); | |
| 926 WaitUntilConnectDone(); | |
| 927 EXPECT_TRUE(has_failed()); | |
| 928 EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_TIMED_OUT", | |
| 929 failure_message()); | |
| 930 } | |
| 931 | |
| 932 // The server doesn't respond to the opening handshake. | |
| 933 TEST_F(WebSocketStreamCreateTest, HandshakeTimeout) { | |
| 934 scoped_ptr<DeterministicSocketData> socket_data(BuildNullSocketData()); | |
| 935 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, ERR_IO_PENDING)); | |
| 936 scoped_ptr<MockWeakTimer> timer(new MockWeakTimer(false, false)); | |
| 937 base::WeakPtr<MockWeakTimer> weak_timer = timer->AsWeakPtr(); | |
| 938 CreateAndConnectRawExpectations("ws://localhost/", | |
| 939 NoSubProtocols(), | |
| 940 "http://localhost", | |
| 941 socket_data.Pass(), | |
| 942 timer.Pass()); | |
| 943 EXPECT_FALSE(has_failed()); | |
| 944 ASSERT_TRUE(weak_timer.get()); | |
| 945 EXPECT_TRUE(weak_timer->IsRunning()); | |
| 946 | |
| 947 weak_timer->Fire(); | |
| 948 WaitUntilConnectDone(); | |
| 949 | |
| 950 EXPECT_TRUE(has_failed()); | |
| 951 EXPECT_EQ("WebSocket opening handshake timed out", failure_message()); | |
| 952 ASSERT_TRUE(weak_timer.get()); | |
| 953 EXPECT_FALSE(weak_timer->IsRunning()); | |
| 954 } | |
| 955 | |
| 956 // When the connection establishes the timer should be stopped. | |
| 957 TEST_F(WebSocketStreamCreateTest, HandshakeTimerOnSuccess) { | |
| 958 scoped_ptr<MockWeakTimer> timer(new MockWeakTimer(false, false)); | |
| 959 base::WeakPtr<MockWeakTimer> weak_timer = timer->AsWeakPtr(); | |
| 960 | |
| 961 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 962 NoSubProtocols(), "http://localhost", "", "", | |
| 963 timer.Pass()); | |
| 964 ASSERT_TRUE(weak_timer); | |
| 965 EXPECT_TRUE(weak_timer->IsRunning()); | |
| 966 | |
| 967 WaitUntilConnectDone(); | |
| 968 EXPECT_FALSE(has_failed()); | |
| 969 EXPECT_TRUE(stream_); | |
| 970 ASSERT_TRUE(weak_timer); | |
| 971 EXPECT_FALSE(weak_timer->IsRunning()); | |
| 972 } | |
| 973 | |
| 974 // When the connection fails the timer should be stopped. | |
| 975 TEST_F(WebSocketStreamCreateTest, HandshakeTimerOnFailure) { | |
| 976 scoped_ptr<DeterministicSocketData> socket_data(BuildNullSocketData()); | |
| 977 socket_data->set_connect_data( | |
| 978 MockConnect(SYNCHRONOUS, ERR_CONNECTION_REFUSED)); | |
| 979 scoped_ptr<MockWeakTimer> timer(new MockWeakTimer(false, false)); | |
| 980 base::WeakPtr<MockWeakTimer> weak_timer = timer->AsWeakPtr(); | |
| 981 CreateAndConnectRawExpectations("ws://localhost/", | |
| 982 NoSubProtocols(), | |
| 983 "http://localhost", | |
| 984 socket_data.Pass(), | |
| 985 timer.Pass()); | |
| 986 ASSERT_TRUE(weak_timer.get()); | |
| 987 EXPECT_TRUE(weak_timer->IsRunning()); | |
| 988 | |
| 989 WaitUntilConnectDone(); | |
| 990 EXPECT_TRUE(has_failed()); | |
| 991 EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_REFUSED", | |
| 992 failure_message()); | |
| 993 ASSERT_TRUE(weak_timer.get()); | |
| 994 EXPECT_FALSE(weak_timer->IsRunning()); | |
| 995 } | |
| 996 | |
| 997 // Cancellation during connect works. | |
| 998 TEST_F(WebSocketStreamCreateTest, CancellationDuringConnect) { | |
| 999 scoped_ptr<DeterministicSocketData> socket_data(BuildNullSocketData()); | |
| 1000 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, ERR_IO_PENDING)); | |
| 1001 CreateAndConnectRawExpectations("ws://localhost/", | |
| 1002 NoSubProtocols(), | |
| 1003 "http://localhost", | |
| 1004 socket_data.Pass()); | |
| 1005 stream_request_.reset(); | |
| 1006 // WaitUntilConnectDone doesn't work in this case. | |
| 1007 base::RunLoop().RunUntilIdle(); | |
| 1008 EXPECT_FALSE(has_failed()); | |
| 1009 EXPECT_FALSE(stream_); | |
| 1010 } | |
| 1011 | |
| 1012 // Cancellation during write of the request headers works. | |
| 1013 TEST_F(WebSocketStreamCreateTest, CancellationDuringWrite) { | |
| 1014 // We seem to need at least two operations in order to use SetStop(). | |
| 1015 MockWrite writes[] = {MockWrite(ASYNC, 0, "GET / HTTP/"), | |
| 1016 MockWrite(ASYNC, 1, "1.1\r\n")}; | |
| 1017 // We keep a copy of the pointer so that we can call RunFor() on it later. | |
| 1018 DeterministicSocketData* socket_data( | |
| 1019 new DeterministicSocketData(NULL, 0, writes, arraysize(writes))); | |
| 1020 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK)); | |
| 1021 socket_data->SetStop(1); | |
| 1022 CreateAndConnectRawExpectations("ws://localhost/", | |
| 1023 NoSubProtocols(), | |
| 1024 "http://localhost", | |
| 1025 make_scoped_ptr(socket_data)); | |
| 1026 socket_data->Run(); | |
| 1027 stream_request_.reset(); | |
| 1028 // WaitUntilConnectDone doesn't work in this case. | |
| 1029 base::RunLoop().RunUntilIdle(); | |
| 1030 EXPECT_FALSE(has_failed()); | |
| 1031 EXPECT_FALSE(stream_); | |
| 1032 EXPECT_TRUE(request_info_); | |
| 1033 EXPECT_FALSE(response_info_); | |
| 1034 } | |
| 1035 | |
| 1036 // Cancellation during read of the response headers works. | |
| 1037 TEST_F(WebSocketStreamCreateTest, CancellationDuringRead) { | |
| 1038 std::string request = | |
| 1039 WebSocketStandardRequest("/", "localhost", "http://localhost", ""); | |
| 1040 MockWrite writes[] = {MockWrite(ASYNC, 0, request.c_str())}; | |
| 1041 MockRead reads[] = { | |
| 1042 MockRead(ASYNC, 1, "HTTP/1.1 101 Switching Protocols\r\nUpgr"), | |
| 1043 }; | |
| 1044 scoped_ptr<DeterministicSocketData> socket_data( | |
| 1045 BuildSocketData(reads, writes)); | |
| 1046 socket_data->SetStop(1); | |
| 1047 DeterministicSocketData* socket_data_raw_ptr = socket_data.get(); | |
| 1048 CreateAndConnectRawExpectations("ws://localhost/", | |
| 1049 NoSubProtocols(), | |
| 1050 "http://localhost", | |
| 1051 socket_data.Pass()); | |
| 1052 socket_data_raw_ptr->Run(); | |
| 1053 stream_request_.reset(); | |
| 1054 // WaitUntilConnectDone doesn't work in this case. | |
| 1055 base::RunLoop().RunUntilIdle(); | |
| 1056 EXPECT_FALSE(has_failed()); | |
| 1057 EXPECT_FALSE(stream_); | |
| 1058 EXPECT_TRUE(request_info_); | |
| 1059 EXPECT_FALSE(response_info_); | |
| 1060 } | |
| 1061 | |
| 1062 // Over-size response headers (> 256KB) should not cause a crash. This is a | |
| 1063 // regression test for crbug.com/339456. It is based on the layout test | |
| 1064 // "cookie-flood.html". | |
| 1065 TEST_F(WebSocketStreamCreateTest, VeryLargeResponseHeaders) { | |
| 1066 std::string set_cookie_headers; | |
| 1067 set_cookie_headers.reserve(45 * 10000); | |
| 1068 for (int i = 0; i < 10000; ++i) { | |
| 1069 set_cookie_headers += | |
| 1070 base::StringPrintf("Set-Cookie: WK-websocket-test-flood-%d=1\r\n", i); | |
| 1071 } | |
| 1072 CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 1073 NoSubProtocols(), "http://localhost", "", | |
| 1074 set_cookie_headers); | |
| 1075 WaitUntilConnectDone(); | |
| 1076 EXPECT_TRUE(has_failed()); | |
| 1077 EXPECT_FALSE(response_info_); | |
| 1078 } | |
| 1079 | |
| 1080 // If the remote host closes the connection without sending headers, we should | |
| 1081 // log the console message "Connection closed before receiving a handshake | |
| 1082 // response". | |
| 1083 TEST_F(WebSocketStreamCreateTest, NoResponse) { | |
| 1084 std::string request = | |
| 1085 WebSocketStandardRequest("/", "localhost", "http://localhost", ""); | |
| 1086 MockWrite writes[] = {MockWrite(ASYNC, request.data(), request.size(), 0)}; | |
| 1087 MockRead reads[] = {MockRead(ASYNC, 0, 1)}; | |
| 1088 scoped_ptr<DeterministicSocketData> socket_data( | |
| 1089 BuildSocketData(reads, writes)); | |
| 1090 DeterministicSocketData* socket_data_raw_ptr = socket_data.get(); | |
| 1091 CreateAndConnectRawExpectations("ws://localhost/", | |
| 1092 NoSubProtocols(), | |
| 1093 "http://localhost", | |
| 1094 socket_data.Pass()); | |
| 1095 socket_data_raw_ptr->RunFor(2); | |
| 1096 EXPECT_TRUE(has_failed()); | |
| 1097 EXPECT_FALSE(stream_); | |
| 1098 EXPECT_FALSE(response_info_); | |
| 1099 EXPECT_EQ("Connection closed before receiving a handshake response", | |
| 1100 failure_message()); | |
| 1101 } | |
| 1102 | |
| 1103 TEST_F(WebSocketStreamCreateTest, SelfSignedCertificateFailure) { | |
| 1104 ssl_data_.push_back( | |
| 1105 new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID)); | |
| 1106 ssl_data_[0]->cert = | |
| 1107 ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der"); | |
| 1108 ASSERT_TRUE(ssl_data_[0]->cert.get()); | |
| 1109 scoped_ptr<DeterministicSocketData> raw_socket_data(BuildNullSocketData()); | |
| 1110 CreateAndConnectRawExpectations("wss://localhost/", | |
| 1111 NoSubProtocols(), | |
| 1112 "http://localhost", | |
| 1113 raw_socket_data.Pass()); | |
| 1114 // WaitUntilConnectDone doesn't work in this case. | |
| 1115 base::RunLoop().RunUntilIdle(); | |
| 1116 EXPECT_FALSE(has_failed()); | |
| 1117 ASSERT_TRUE(ssl_error_callbacks_); | |
| 1118 ssl_error_callbacks_->CancelSSLRequest(ERR_CERT_AUTHORITY_INVALID, | |
| 1119 &ssl_info_); | |
| 1120 WaitUntilConnectDone(); | |
| 1121 EXPECT_TRUE(has_failed()); | |
| 1122 } | |
| 1123 | |
| 1124 TEST_F(WebSocketStreamCreateTest, SelfSignedCertificateSuccess) { | |
| 1125 scoped_ptr<SSLSocketDataProvider> ssl_data( | |
| 1126 new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID)); | |
| 1127 ssl_data->cert = | |
| 1128 ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der"); | |
| 1129 ASSERT_TRUE(ssl_data->cert.get()); | |
| 1130 ssl_data_.push_back(ssl_data.release()); | |
| 1131 ssl_data.reset(new SSLSocketDataProvider(ASYNC, OK)); | |
| 1132 ssl_data_.push_back(ssl_data.release()); | |
| 1133 url_request_context_host_.AddRawExpectations(BuildNullSocketData()); | |
| 1134 CreateAndConnectStandard("wss://localhost/", "localhost", "/", | |
| 1135 NoSubProtocols(), "http://localhost", "", ""); | |
| 1136 // WaitUntilConnectDone doesn't work in this case. | |
| 1137 base::RunLoop().RunUntilIdle(); | |
| 1138 ASSERT_TRUE(ssl_error_callbacks_); | |
| 1139 ssl_error_callbacks_->ContinueSSLRequest(); | |
| 1140 WaitUntilConnectDone(); | |
| 1141 EXPECT_FALSE(has_failed()); | |
| 1142 EXPECT_TRUE(stream_); | |
| 1143 } | |
| 1144 | |
| 1145 // If the server requests authorisation, but we have no credentials, the | |
| 1146 // connection should fail cleanly. | |
| 1147 TEST_F(WebSocketStreamCreateBasicAuthTest, FailureNoCredentials) { | |
| 1148 CreateAndConnectCustomResponse("ws://localhost/", "localhost", "/", | |
| 1149 NoSubProtocols(), "http://localhost", "", | |
| 1150 kUnauthorizedResponse); | |
| 1151 WaitUntilConnectDone(); | |
| 1152 EXPECT_TRUE(has_failed()); | |
| 1153 EXPECT_EQ("HTTP Authentication failed; no valid credentials available", | |
| 1154 failure_message()); | |
| 1155 EXPECT_TRUE(response_info_); | |
| 1156 } | |
| 1157 | |
| 1158 TEST_F(WebSocketStreamCreateBasicAuthTest, SuccessPasswordInUrl) { | |
| 1159 CreateAndConnectAuthHandshake("ws://foo:bar@localhost/", | |
| 1160 "Zm9vOmJhcg==", | |
| 1161 WebSocketStandardResponse(std::string())); | |
| 1162 WaitUntilConnectDone(); | |
| 1163 EXPECT_FALSE(has_failed()); | |
| 1164 EXPECT_TRUE(stream_); | |
| 1165 ASSERT_TRUE(response_info_); | |
| 1166 EXPECT_EQ(101, response_info_->status_code); | |
| 1167 } | |
| 1168 | |
| 1169 TEST_F(WebSocketStreamCreateBasicAuthTest, FailureIncorrectPasswordInUrl) { | |
| 1170 CreateAndConnectAuthHandshake( | |
| 1171 "ws://foo:baz@localhost/", "Zm9vOmJheg==", kUnauthorizedResponse); | |
| 1172 WaitUntilConnectDone(); | |
| 1173 EXPECT_TRUE(has_failed()); | |
| 1174 EXPECT_TRUE(response_info_); | |
| 1175 } | |
| 1176 | |
| 1177 // Digest auth has the same connection semantics as Basic auth, so we can | |
| 1178 // generally assume that whatever works for Basic auth will also work for | |
| 1179 // Digest. There's just one test here, to confirm that it works at all. | |
| 1180 TEST_F(WebSocketStreamCreateDigestAuthTest, DigestPasswordInUrl) { | |
| 1181 AddRawExpectations(helper_.BuildSocketData1(kUnauthorizedResponse)); | |
| 1182 | |
| 1183 CreateAndConnectRawExpectations( | |
| 1184 "ws://FooBar:pass@localhost/", | |
| 1185 NoSubProtocols(), | |
| 1186 "http://localhost", | |
| 1187 helper_.BuildSocketData2(kAuthorizedRequest, | |
| 1188 WebSocketStandardResponse(std::string()))); | |
| 1189 WaitUntilConnectDone(); | |
| 1190 EXPECT_FALSE(has_failed()); | |
| 1191 EXPECT_TRUE(stream_); | |
| 1192 ASSERT_TRUE(response_info_); | |
| 1193 EXPECT_EQ(101, response_info_->status_code); | |
| 1194 } | |
| 1195 | |
| 1196 TEST_F(WebSocketStreamCreateUMATest, Incomplete) { | |
| 1197 const std::string name("Net.WebSocket.HandshakeResult"); | |
| 1198 scoped_ptr<base::HistogramSamples> original(GetSamples(name)); | |
| 1199 | |
| 1200 { | |
| 1201 StreamCreation creation; | |
| 1202 creation.CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 1203 creation.NoSubProtocols(), | |
| 1204 "http://localhost", "", ""); | |
| 1205 } | |
| 1206 | |
| 1207 scoped_ptr<base::HistogramSamples> samples(GetSamples(name)); | |
| 1208 ASSERT_TRUE(samples); | |
| 1209 if (original) { | |
| 1210 samples->Subtract(*original); // Cancel the original values. | |
| 1211 } | |
| 1212 EXPECT_EQ(1, samples->GetCount(INCOMPLETE)); | |
| 1213 EXPECT_EQ(0, samples->GetCount(CONNECTED)); | |
| 1214 EXPECT_EQ(0, samples->GetCount(FAILED)); | |
| 1215 } | |
| 1216 | |
| 1217 TEST_F(WebSocketStreamCreateUMATest, Connected) { | |
| 1218 const std::string name("Net.WebSocket.HandshakeResult"); | |
| 1219 scoped_ptr<base::HistogramSamples> original(GetSamples(name)); | |
| 1220 | |
| 1221 { | |
| 1222 StreamCreation creation; | |
| 1223 creation.CreateAndConnectStandard("ws://localhost/", "localhost", "/", | |
| 1224 creation.NoSubProtocols(), | |
| 1225 "http://localhost", "", ""); | |
| 1226 creation.WaitUntilConnectDone(); | |
| 1227 } | |
| 1228 | |
| 1229 scoped_ptr<base::HistogramSamples> samples(GetSamples(name)); | |
| 1230 ASSERT_TRUE(samples); | |
| 1231 if (original) { | |
| 1232 samples->Subtract(*original); // Cancel the original values. | |
| 1233 } | |
| 1234 EXPECT_EQ(0, samples->GetCount(INCOMPLETE)); | |
| 1235 EXPECT_EQ(1, samples->GetCount(CONNECTED)); | |
| 1236 EXPECT_EQ(0, samples->GetCount(FAILED)); | |
| 1237 } | |
| 1238 | |
| 1239 TEST_F(WebSocketStreamCreateUMATest, Failed) { | |
| 1240 const std::string name("Net.WebSocket.HandshakeResult"); | |
| 1241 scoped_ptr<base::HistogramSamples> original(GetSamples(name)); | |
| 1242 | |
| 1243 { | |
| 1244 StreamCreation creation; | |
| 1245 static const char kInvalidStatusCodeResponse[] = | |
| 1246 "HTTP/1.1 200 OK\r\n" | |
| 1247 "Upgrade: websocket\r\n" | |
| 1248 "Connection: Upgrade\r\n" | |
| 1249 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 1250 "\r\n"; | |
| 1251 creation.CreateAndConnectCustomResponse( | |
| 1252 "ws://localhost/", "localhost", "/", creation.NoSubProtocols(), | |
| 1253 "http://localhost", "", kInvalidStatusCodeResponse); | |
| 1254 creation.WaitUntilConnectDone(); | |
| 1255 } | |
| 1256 | |
| 1257 scoped_ptr<base::HistogramSamples> samples(GetSamples(name)); | |
| 1258 ASSERT_TRUE(samples); | |
| 1259 if (original) { | |
| 1260 samples->Subtract(*original); // Cancel the original values. | |
| 1261 } | |
| 1262 EXPECT_EQ(1, samples->GetCount(INCOMPLETE)); | |
| 1263 EXPECT_EQ(0, samples->GetCount(CONNECTED)); | |
| 1264 EXPECT_EQ(0, samples->GetCount(FAILED)); | |
| 1265 } | |
| 1266 | |
| 1267 TEST_F(WebSocketStreamCreateTest, HandleErrConnectionClosed) { | |
| 1268 static const char kTruncatedResponse[] = | |
| 1269 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 1270 "Upgrade: websocket\r\n" | |
| 1271 "Connection: Upgrade\r\n" | |
| 1272 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 1273 "Cache-Control: no-sto"; | |
| 1274 | |
| 1275 std::string request = | |
| 1276 WebSocketStandardRequest("/", "localhost", "http://localhost", ""); | |
| 1277 MockRead reads[] = { | |
| 1278 MockRead(SYNCHRONOUS, 1, kTruncatedResponse), | |
| 1279 MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED, 2), | |
| 1280 }; | |
| 1281 MockWrite writes[] = {MockWrite(SYNCHRONOUS, 0, request.c_str())}; | |
| 1282 scoped_ptr<DeterministicSocketData> socket_data( | |
| 1283 BuildSocketData(reads, writes)); | |
| 1284 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK)); | |
| 1285 CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(), | |
| 1286 "http://localhost", socket_data.Pass()); | |
| 1287 WaitUntilConnectDone(); | |
| 1288 EXPECT_TRUE(has_failed()); | |
| 1289 } | |
| 1290 | |
| 1291 TEST_F(WebSocketStreamCreateTest, HandleErrTunnelConnectionFailed) { | |
| 1292 static const char kConnectRequest[] = | |
| 1293 "CONNECT localhost:80 HTTP/1.1\r\n" | |
| 1294 "Host: localhost\r\n" | |
| 1295 "Proxy-Connection: keep-alive\r\n" | |
| 1296 "\r\n"; | |
| 1297 | |
| 1298 static const char kProxyResponse[] = | |
| 1299 "HTTP/1.1 403 Forbidden\r\n" | |
| 1300 "Content-Type: text/html\r\n" | |
| 1301 "Content-Length: 9\r\n" | |
| 1302 "Connection: keep-alive\r\n" | |
| 1303 "\r\n" | |
| 1304 "Forbidden"; | |
| 1305 | |
| 1306 MockRead reads[] = {MockRead(SYNCHRONOUS, 1, kProxyResponse)}; | |
| 1307 MockWrite writes[] = {MockWrite(SYNCHRONOUS, 0, kConnectRequest)}; | |
| 1308 scoped_ptr<DeterministicSocketData> socket_data( | |
| 1309 BuildSocketData(reads, writes)); | |
| 1310 url_request_context_host_.SetProxyConfig("https=proxy:8000"); | |
| 1311 CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(), | |
| 1312 "http://localhost", socket_data.Pass()); | |
| 1313 WaitUntilConnectDone(); | |
| 1314 EXPECT_TRUE(has_failed()); | |
| 1315 EXPECT_EQ("Establishing a tunnel via proxy server failed.", | |
| 1316 failure_message()); | |
| 1317 } | |
| 1318 | |
| 1319 } // namespace | |
| 1320 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master