| 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_job.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/bind_helpers.h" | |
| 12 #include "base/callback.h" | |
| 13 #include "base/memory/ref_counted.h" | |
| 14 #include "base/strings/string_split.h" | |
| 15 #include "base/strings/string_util.h" | |
| 16 #include "net/base/completion_callback.h" | |
| 17 #include "net/base/net_errors.h" | |
| 18 #include "net/base/test_completion_callback.h" | |
| 19 #include "net/cookies/cookie_store.h" | |
| 20 #include "net/cookies/cookie_store_test_helpers.h" | |
| 21 #include "net/dns/mock_host_resolver.h" | |
| 22 #include "net/http/http_transaction_factory.h" | |
| 23 #include "net/http/transport_security_state.h" | |
| 24 #include "net/proxy/proxy_service.h" | |
| 25 #include "net/socket/next_proto.h" | |
| 26 #include "net/socket/socket_test_util.h" | |
| 27 #include "net/socket_stream/socket_stream.h" | |
| 28 #include "net/spdy/spdy_session.h" | |
| 29 #include "net/spdy/spdy_websocket_test_util.h" | |
| 30 #include "net/ssl/ssl_config_service.h" | |
| 31 #include "net/url_request/url_request_context.h" | |
| 32 #include "net/websockets/websocket_throttle.h" | |
| 33 #include "testing/gmock/include/gmock/gmock.h" | |
| 34 #include "testing/gtest/include/gtest/gtest.h" | |
| 35 #include "testing/platform_test.h" | |
| 36 #include "url/gurl.h" | |
| 37 | |
| 38 namespace net { | |
| 39 | |
| 40 namespace { | |
| 41 | |
| 42 class MockSocketStream : public SocketStream { | |
| 43 public: | |
| 44 MockSocketStream(const GURL& url, SocketStream::Delegate* delegate, | |
| 45 URLRequestContext* context, CookieStore* cookie_store) | |
| 46 : SocketStream(url, delegate, context, cookie_store) {} | |
| 47 | |
| 48 void Connect() override {} | |
| 49 bool SendData(const char* data, int len) override { | |
| 50 sent_data_ += std::string(data, len); | |
| 51 return true; | |
| 52 } | |
| 53 | |
| 54 void Close() override {} | |
| 55 void RestartWithAuth(const AuthCredentials& credentials) override {} | |
| 56 | |
| 57 void DetachDelegate() override { delegate_ = NULL; } | |
| 58 | |
| 59 const std::string& sent_data() const { | |
| 60 return sent_data_; | |
| 61 } | |
| 62 | |
| 63 protected: | |
| 64 ~MockSocketStream() override {} | |
| 65 | |
| 66 private: | |
| 67 std::string sent_data_; | |
| 68 }; | |
| 69 | |
| 70 class MockSocketStreamDelegate : public SocketStream::Delegate { | |
| 71 public: | |
| 72 MockSocketStreamDelegate() | |
| 73 : amount_sent_(0), allow_all_cookies_(true) {} | |
| 74 void set_allow_all_cookies(bool allow_all_cookies) { | |
| 75 allow_all_cookies_ = allow_all_cookies; | |
| 76 } | |
| 77 ~MockSocketStreamDelegate() override {} | |
| 78 | |
| 79 void SetOnStartOpenConnection(const base::Closure& callback) { | |
| 80 on_start_open_connection_ = callback; | |
| 81 } | |
| 82 void SetOnConnected(const base::Closure& callback) { | |
| 83 on_connected_ = callback; | |
| 84 } | |
| 85 void SetOnSentData(const base::Closure& callback) { | |
| 86 on_sent_data_ = callback; | |
| 87 } | |
| 88 void SetOnReceivedData(const base::Closure& callback) { | |
| 89 on_received_data_ = callback; | |
| 90 } | |
| 91 void SetOnClose(const base::Closure& callback) { | |
| 92 on_close_ = callback; | |
| 93 } | |
| 94 | |
| 95 int OnStartOpenConnection(SocketStream* socket, | |
| 96 const CompletionCallback& callback) override { | |
| 97 if (!on_start_open_connection_.is_null()) | |
| 98 on_start_open_connection_.Run(); | |
| 99 return OK; | |
| 100 } | |
| 101 void OnConnected(SocketStream* socket, | |
| 102 int max_pending_send_allowed) override { | |
| 103 if (!on_connected_.is_null()) | |
| 104 on_connected_.Run(); | |
| 105 } | |
| 106 void OnSentData(SocketStream* socket, int amount_sent) override { | |
| 107 amount_sent_ += amount_sent; | |
| 108 if (!on_sent_data_.is_null()) | |
| 109 on_sent_data_.Run(); | |
| 110 } | |
| 111 void OnReceivedData(SocketStream* socket, | |
| 112 const char* data, | |
| 113 int len) override { | |
| 114 received_data_ += std::string(data, len); | |
| 115 if (!on_received_data_.is_null()) | |
| 116 on_received_data_.Run(); | |
| 117 } | |
| 118 void OnClose(SocketStream* socket) override { | |
| 119 if (!on_close_.is_null()) | |
| 120 on_close_.Run(); | |
| 121 } | |
| 122 bool CanGetCookies(SocketStream* socket, const GURL& url) override { | |
| 123 return allow_all_cookies_; | |
| 124 } | |
| 125 bool CanSetCookie(SocketStream* request, | |
| 126 const GURL& url, | |
| 127 const std::string& cookie_line, | |
| 128 CookieOptions* options) override { | |
| 129 return allow_all_cookies_; | |
| 130 } | |
| 131 | |
| 132 size_t amount_sent() const { return amount_sent_; } | |
| 133 const std::string& received_data() const { return received_data_; } | |
| 134 | |
| 135 private: | |
| 136 int amount_sent_; | |
| 137 bool allow_all_cookies_; | |
| 138 std::string received_data_; | |
| 139 base::Closure on_start_open_connection_; | |
| 140 base::Closure on_connected_; | |
| 141 base::Closure on_sent_data_; | |
| 142 base::Closure on_received_data_; | |
| 143 base::Closure on_close_; | |
| 144 }; | |
| 145 | |
| 146 class MockCookieStore : public CookieStore { | |
| 147 public: | |
| 148 struct Entry { | |
| 149 GURL url; | |
| 150 std::string cookie_line; | |
| 151 CookieOptions options; | |
| 152 }; | |
| 153 | |
| 154 MockCookieStore() {} | |
| 155 | |
| 156 bool SetCookieWithOptions(const GURL& url, | |
| 157 const std::string& cookie_line, | |
| 158 const CookieOptions& options) { | |
| 159 Entry entry; | |
| 160 entry.url = url; | |
| 161 entry.cookie_line = cookie_line; | |
| 162 entry.options = options; | |
| 163 entries_.push_back(entry); | |
| 164 return true; | |
| 165 } | |
| 166 | |
| 167 std::string GetCookiesWithOptions(const GURL& url, | |
| 168 const CookieOptions& options) { | |
| 169 std::string result; | |
| 170 for (size_t i = 0; i < entries_.size(); i++) { | |
| 171 Entry& entry = entries_[i]; | |
| 172 if (url == entry.url) { | |
| 173 if (!result.empty()) { | |
| 174 result += "; "; | |
| 175 } | |
| 176 result += entry.cookie_line; | |
| 177 } | |
| 178 } | |
| 179 return result; | |
| 180 } | |
| 181 | |
| 182 // CookieStore: | |
| 183 void SetCookieWithOptionsAsync(const GURL& url, | |
| 184 const std::string& cookie_line, | |
| 185 const CookieOptions& options, | |
| 186 const SetCookiesCallback& callback) override { | |
| 187 bool result = SetCookieWithOptions(url, cookie_line, options); | |
| 188 if (!callback.is_null()) | |
| 189 callback.Run(result); | |
| 190 } | |
| 191 | |
| 192 void GetCookiesWithOptionsAsync(const GURL& url, | |
| 193 const CookieOptions& options, | |
| 194 const GetCookiesCallback& callback) override { | |
| 195 if (!callback.is_null()) | |
| 196 callback.Run(GetCookiesWithOptions(url, options)); | |
| 197 } | |
| 198 | |
| 199 void GetAllCookiesForURLAsync( | |
| 200 const GURL& url, | |
| 201 const GetCookieListCallback& callback) override { | |
| 202 ADD_FAILURE(); | |
| 203 } | |
| 204 | |
| 205 void DeleteCookieAsync(const GURL& url, | |
| 206 const std::string& cookie_name, | |
| 207 const base::Closure& callback) override { | |
| 208 ADD_FAILURE(); | |
| 209 } | |
| 210 | |
| 211 void DeleteAllCreatedBetweenAsync(const base::Time& delete_begin, | |
| 212 const base::Time& delete_end, | |
| 213 const DeleteCallback& callback) override { | |
| 214 ADD_FAILURE(); | |
| 215 } | |
| 216 | |
| 217 void DeleteAllCreatedBetweenForHostAsync( | |
| 218 const base::Time delete_begin, | |
| 219 const base::Time delete_end, | |
| 220 const GURL& url, | |
| 221 const DeleteCallback& callback) override { | |
| 222 ADD_FAILURE(); | |
| 223 } | |
| 224 | |
| 225 void DeleteSessionCookiesAsync(const DeleteCallback&) override { | |
| 226 ADD_FAILURE(); | |
| 227 } | |
| 228 | |
| 229 CookieMonster* GetCookieMonster() override { return NULL; } | |
| 230 | |
| 231 scoped_ptr<CookieStore::CookieChangedSubscription> | |
| 232 AddCallbackForCookie(const GURL& url, const std::string& name, | |
| 233 const CookieChangedCallback& callback) override { | |
| 234 ADD_FAILURE(); | |
| 235 return scoped_ptr<CookieChangedSubscription>(); | |
| 236 } | |
| 237 | |
| 238 const std::vector<Entry>& entries() const { return entries_; } | |
| 239 | |
| 240 private: | |
| 241 friend class base::RefCountedThreadSafe<MockCookieStore>; | |
| 242 ~MockCookieStore() override {} | |
| 243 | |
| 244 std::vector<Entry> entries_; | |
| 245 }; | |
| 246 | |
| 247 class MockSSLConfigService : public SSLConfigService { | |
| 248 public: | |
| 249 void GetSSLConfig(SSLConfig* config) override {} | |
| 250 | |
| 251 protected: | |
| 252 ~MockSSLConfigService() override {} | |
| 253 }; | |
| 254 | |
| 255 class MockURLRequestContext : public URLRequestContext { | |
| 256 public: | |
| 257 explicit MockURLRequestContext(CookieStore* cookie_store) | |
| 258 : transport_security_state_() { | |
| 259 set_cookie_store(cookie_store); | |
| 260 set_transport_security_state(&transport_security_state_); | |
| 261 base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000); | |
| 262 bool include_subdomains = false; | |
| 263 transport_security_state_.AddHSTS("upgrademe.com", expiry, | |
| 264 include_subdomains); | |
| 265 } | |
| 266 | |
| 267 ~MockURLRequestContext() override { AssertNoURLRequests(); } | |
| 268 | |
| 269 private: | |
| 270 TransportSecurityState transport_security_state_; | |
| 271 }; | |
| 272 | |
| 273 class MockHttpTransactionFactory : public HttpTransactionFactory { | |
| 274 public: | |
| 275 MockHttpTransactionFactory(NextProto next_proto, | |
| 276 OrderedSocketData* data, | |
| 277 bool enable_websocket_over_spdy) { | |
| 278 data_ = data; | |
| 279 MockConnect connect_data(SYNCHRONOUS, OK); | |
| 280 data_->set_connect_data(connect_data); | |
| 281 session_deps_.reset(new SpdySessionDependencies(next_proto)); | |
| 282 session_deps_->enable_websocket_over_spdy = enable_websocket_over_spdy; | |
| 283 session_deps_->socket_factory->AddSocketDataProvider(data_); | |
| 284 http_session_ = | |
| 285 SpdySessionDependencies::SpdyCreateSession(session_deps_.get()); | |
| 286 host_port_pair_.set_host("example.com"); | |
| 287 host_port_pair_.set_port(80); | |
| 288 spdy_session_key_ = SpdySessionKey(host_port_pair_, | |
| 289 ProxyServer::Direct(), | |
| 290 PRIVACY_MODE_DISABLED); | |
| 291 session_ = CreateInsecureSpdySession( | |
| 292 http_session_, spdy_session_key_, BoundNetLog()); | |
| 293 } | |
| 294 | |
| 295 int CreateTransaction(RequestPriority priority, | |
| 296 scoped_ptr<HttpTransaction>* trans) override { | |
| 297 NOTREACHED(); | |
| 298 return ERR_UNEXPECTED; | |
| 299 } | |
| 300 | |
| 301 HttpCache* GetCache() override { | |
| 302 NOTREACHED(); | |
| 303 return NULL; | |
| 304 } | |
| 305 | |
| 306 HttpNetworkSession* GetSession() override { return http_session_.get(); } | |
| 307 | |
| 308 private: | |
| 309 OrderedSocketData* data_; | |
| 310 scoped_ptr<SpdySessionDependencies> session_deps_; | |
| 311 scoped_refptr<HttpNetworkSession> http_session_; | |
| 312 base::WeakPtr<SpdySession> session_; | |
| 313 HostPortPair host_port_pair_; | |
| 314 SpdySessionKey spdy_session_key_; | |
| 315 }; | |
| 316 | |
| 317 class DeletingSocketStreamDelegate : public SocketStream::Delegate { | |
| 318 public: | |
| 319 DeletingSocketStreamDelegate() | |
| 320 : delete_next_(false) {} | |
| 321 | |
| 322 // Since this class needs to be able to delete |job_|, it must be the only | |
| 323 // reference holder (except for temporary references). Provide access to the | |
| 324 // pointer for tests to use. | |
| 325 WebSocketJob* job() { return job_.get(); } | |
| 326 | |
| 327 void set_job(WebSocketJob* job) { job_ = job; } | |
| 328 | |
| 329 // After calling this, the next call to a method on this delegate will delete | |
| 330 // the WebSocketJob object. | |
| 331 void set_delete_next(bool delete_next) { delete_next_ = delete_next; } | |
| 332 | |
| 333 void DeleteJobMaybe() { | |
| 334 if (delete_next_) { | |
| 335 job_->DetachContext(); | |
| 336 job_->DetachDelegate(); | |
| 337 job_ = NULL; | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 // SocketStream::Delegate implementation | |
| 342 | |
| 343 // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost | |
| 344 | |
| 345 void OnConnected(SocketStream* socket, | |
| 346 int max_pending_send_allowed) override { | |
| 347 DeleteJobMaybe(); | |
| 348 } | |
| 349 | |
| 350 void OnSentData(SocketStream* socket, int amount_sent) override { | |
| 351 DeleteJobMaybe(); | |
| 352 } | |
| 353 | |
| 354 void OnReceivedData(SocketStream* socket, | |
| 355 const char* data, | |
| 356 int len) override { | |
| 357 DeleteJobMaybe(); | |
| 358 } | |
| 359 | |
| 360 void OnClose(SocketStream* socket) override { DeleteJobMaybe(); } | |
| 361 | |
| 362 void OnAuthRequired(SocketStream* socket, | |
| 363 AuthChallengeInfo* auth_info) override { | |
| 364 DeleteJobMaybe(); | |
| 365 } | |
| 366 | |
| 367 void OnSSLCertificateError(SocketStream* socket, | |
| 368 const SSLInfo& ssl_info, | |
| 369 bool fatal) override { | |
| 370 DeleteJobMaybe(); | |
| 371 } | |
| 372 | |
| 373 void OnError(const SocketStream* socket, int error) override { | |
| 374 DeleteJobMaybe(); | |
| 375 } | |
| 376 | |
| 377 // CanGetCookies() and CanSetCookies() do not appear to be able to delete the | |
| 378 // WebSocketJob object. | |
| 379 | |
| 380 private: | |
| 381 scoped_refptr<WebSocketJob> job_; | |
| 382 bool delete_next_; | |
| 383 }; | |
| 384 | |
| 385 } // namespace | |
| 386 | |
| 387 class WebSocketJobTest : public PlatformTest, | |
| 388 public ::testing::WithParamInterface<NextProto> { | |
| 389 public: | |
| 390 WebSocketJobTest() | |
| 391 : spdy_util_(GetParam()), | |
| 392 enable_websocket_over_spdy_(false) {} | |
| 393 | |
| 394 void SetUp() override { | |
| 395 stream_type_ = STREAM_INVALID; | |
| 396 cookie_store_ = new MockCookieStore; | |
| 397 context_.reset(new MockURLRequestContext(cookie_store_.get())); | |
| 398 } | |
| 399 void TearDown() override { | |
| 400 cookie_store_ = NULL; | |
| 401 context_.reset(); | |
| 402 websocket_ = NULL; | |
| 403 socket_ = NULL; | |
| 404 } | |
| 405 void DoSendRequest() { | |
| 406 EXPECT_TRUE(websocket_->SendData(kHandshakeRequestWithoutCookie, | |
| 407 kHandshakeRequestWithoutCookieLength)); | |
| 408 } | |
| 409 void DoSendData() { | |
| 410 if (received_data().size() == kHandshakeResponseWithoutCookieLength) | |
| 411 websocket_->SendData(kDataHello, kDataHelloLength); | |
| 412 } | |
| 413 void DoSync() { | |
| 414 sync_test_callback_.callback().Run(OK); | |
| 415 } | |
| 416 int WaitForResult() { | |
| 417 return sync_test_callback_.WaitForResult(); | |
| 418 } | |
| 419 | |
| 420 protected: | |
| 421 enum StreamType { | |
| 422 STREAM_INVALID, | |
| 423 STREAM_MOCK_SOCKET, | |
| 424 STREAM_SOCKET, | |
| 425 STREAM_SPDY_WEBSOCKET, | |
| 426 }; | |
| 427 enum ThrottlingOption { | |
| 428 THROTTLING_OFF, | |
| 429 THROTTLING_ON, | |
| 430 }; | |
| 431 enum SpdyOption { | |
| 432 SPDY_OFF, | |
| 433 SPDY_ON, | |
| 434 }; | |
| 435 void InitWebSocketJob(const GURL& url, | |
| 436 MockSocketStreamDelegate* delegate, | |
| 437 StreamType stream_type) { | |
| 438 DCHECK_NE(STREAM_INVALID, stream_type); | |
| 439 stream_type_ = stream_type; | |
| 440 websocket_ = new WebSocketJob(delegate); | |
| 441 | |
| 442 if (stream_type == STREAM_MOCK_SOCKET) | |
| 443 socket_ = new MockSocketStream(url, websocket_.get(), context_.get(), | |
| 444 NULL); | |
| 445 | |
| 446 if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) { | |
| 447 if (stream_type == STREAM_SPDY_WEBSOCKET) { | |
| 448 http_factory_.reset(new MockHttpTransactionFactory( | |
| 449 GetParam(), data_.get(), enable_websocket_over_spdy_)); | |
| 450 context_->set_http_transaction_factory(http_factory_.get()); | |
| 451 } | |
| 452 | |
| 453 ssl_config_service_ = new MockSSLConfigService(); | |
| 454 context_->set_ssl_config_service(ssl_config_service_.get()); | |
| 455 proxy_service_.reset(ProxyService::CreateDirect()); | |
| 456 context_->set_proxy_service(proxy_service_.get()); | |
| 457 host_resolver_.reset(new MockHostResolver); | |
| 458 context_->set_host_resolver(host_resolver_.get()); | |
| 459 | |
| 460 socket_ = new SocketStream(url, websocket_.get(), context_.get(), NULL); | |
| 461 socket_factory_.reset(new MockClientSocketFactory); | |
| 462 DCHECK(data_.get()); | |
| 463 socket_factory_->AddSocketDataProvider(data_.get()); | |
| 464 socket_->SetClientSocketFactory(socket_factory_.get()); | |
| 465 } | |
| 466 | |
| 467 websocket_->InitSocketStream(socket_.get()); | |
| 468 // MockHostResolver resolves all hosts to 127.0.0.1; however, when we create | |
| 469 // a WebSocketJob purely to block another one in a throttling test, we don't | |
| 470 // perform a real connect. In that case, the following address is used | |
| 471 // instead. | |
| 472 IPAddressNumber ip; | |
| 473 ParseIPLiteralToNumber("127.0.0.1", &ip); | |
| 474 websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 80); | |
| 475 } | |
| 476 void SkipToConnecting() { | |
| 477 websocket_->state_ = WebSocketJob::CONNECTING; | |
| 478 ASSERT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get())); | |
| 479 } | |
| 480 WebSocketJob::State GetWebSocketJobState() { | |
| 481 return websocket_->state_; | |
| 482 } | |
| 483 void CloseWebSocketJob() { | |
| 484 if (websocket_->socket_.get()) { | |
| 485 websocket_->socket_->DetachDelegate(); | |
| 486 WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get()); | |
| 487 } | |
| 488 websocket_->state_ = WebSocketJob::CLOSED; | |
| 489 websocket_->delegate_ = NULL; | |
| 490 websocket_->socket_ = NULL; | |
| 491 } | |
| 492 SocketStream* GetSocket(SocketStreamJob* job) { | |
| 493 return job->socket_.get(); | |
| 494 } | |
| 495 const std::string& sent_data() const { | |
| 496 DCHECK_EQ(STREAM_MOCK_SOCKET, stream_type_); | |
| 497 MockSocketStream* socket = | |
| 498 static_cast<MockSocketStream*>(socket_.get()); | |
| 499 DCHECK(socket); | |
| 500 return socket->sent_data(); | |
| 501 } | |
| 502 const std::string& received_data() const { | |
| 503 DCHECK_NE(STREAM_INVALID, stream_type_); | |
| 504 MockSocketStreamDelegate* delegate = | |
| 505 static_cast<MockSocketStreamDelegate*>(websocket_->delegate_); | |
| 506 DCHECK(delegate); | |
| 507 return delegate->received_data(); | |
| 508 } | |
| 509 | |
| 510 void TestSimpleHandshake(); | |
| 511 void TestSlowHandshake(); | |
| 512 void TestHandshakeWithCookie(); | |
| 513 void TestHandshakeWithCookieButNotAllowed(); | |
| 514 void TestHSTSUpgrade(); | |
| 515 void TestInvalidSendData(); | |
| 516 void TestConnectByWebSocket(ThrottlingOption throttling); | |
| 517 void TestConnectBySpdy(SpdyOption spdy, ThrottlingOption throttling); | |
| 518 void TestThrottlingLimit(); | |
| 519 | |
| 520 SpdyWebSocketTestUtil spdy_util_; | |
| 521 StreamType stream_type_; | |
| 522 scoped_refptr<MockCookieStore> cookie_store_; | |
| 523 scoped_ptr<MockURLRequestContext> context_; | |
| 524 scoped_refptr<WebSocketJob> websocket_; | |
| 525 scoped_refptr<SocketStream> socket_; | |
| 526 scoped_ptr<MockClientSocketFactory> socket_factory_; | |
| 527 scoped_ptr<OrderedSocketData> data_; | |
| 528 TestCompletionCallback sync_test_callback_; | |
| 529 scoped_refptr<MockSSLConfigService> ssl_config_service_; | |
| 530 scoped_ptr<ProxyService> proxy_service_; | |
| 531 scoped_ptr<MockHostResolver> host_resolver_; | |
| 532 scoped_ptr<MockHttpTransactionFactory> http_factory_; | |
| 533 | |
| 534 // Must be set before call to enable_websocket_over_spdy, defaults to false. | |
| 535 bool enable_websocket_over_spdy_; | |
| 536 | |
| 537 static const char kHandshakeRequestWithoutCookie[]; | |
| 538 static const char kHandshakeRequestWithCookie[]; | |
| 539 static const char kHandshakeRequestWithFilteredCookie[]; | |
| 540 static const char kHandshakeResponseWithoutCookie[]; | |
| 541 static const char kHandshakeResponseWithCookie[]; | |
| 542 static const char kDataHello[]; | |
| 543 static const char kDataWorld[]; | |
| 544 static const char* const kHandshakeRequestForSpdy[]; | |
| 545 static const char* const kHandshakeResponseForSpdy[]; | |
| 546 static const size_t kHandshakeRequestWithoutCookieLength; | |
| 547 static const size_t kHandshakeRequestWithCookieLength; | |
| 548 static const size_t kHandshakeRequestWithFilteredCookieLength; | |
| 549 static const size_t kHandshakeResponseWithoutCookieLength; | |
| 550 static const size_t kHandshakeResponseWithCookieLength; | |
| 551 static const size_t kDataHelloLength; | |
| 552 static const size_t kDataWorldLength; | |
| 553 }; | |
| 554 | |
| 555 // Tests using this fixture verify that the WebSocketJob can handle being | |
| 556 // deleted while calling back to the delegate correctly. These tests need to be | |
| 557 // run under AddressSanitizer or other systems for detecting use-after-free | |
| 558 // errors in order to find problems. | |
| 559 class WebSocketJobDeleteTest : public ::testing::Test { | |
| 560 protected: | |
| 561 WebSocketJobDeleteTest() | |
| 562 : delegate_(new DeletingSocketStreamDelegate), | |
| 563 cookie_store_(new MockCookieStore), | |
| 564 context_(new MockURLRequestContext(cookie_store_.get())) { | |
| 565 WebSocketJob* websocket = new WebSocketJob(delegate_.get()); | |
| 566 delegate_->set_job(websocket); | |
| 567 | |
| 568 socket_ = new MockSocketStream( | |
| 569 GURL("ws://127.0.0.1/"), websocket, context_.get(), NULL); | |
| 570 | |
| 571 websocket->InitSocketStream(socket_.get()); | |
| 572 } | |
| 573 | |
| 574 void SetDeleteNext() { return delegate_->set_delete_next(true); } | |
| 575 WebSocketJob* job() { return delegate_->job(); } | |
| 576 | |
| 577 scoped_ptr<DeletingSocketStreamDelegate> delegate_; | |
| 578 scoped_refptr<MockCookieStore> cookie_store_; | |
| 579 scoped_ptr<MockURLRequestContext> context_; | |
| 580 scoped_refptr<SocketStream> socket_; | |
| 581 }; | |
| 582 | |
| 583 const char WebSocketJobTest::kHandshakeRequestWithoutCookie[] = | |
| 584 "GET /demo HTTP/1.1\r\n" | |
| 585 "Host: example.com\r\n" | |
| 586 "Upgrade: WebSocket\r\n" | |
| 587 "Connection: Upgrade\r\n" | |
| 588 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 589 "Origin: http://example.com\r\n" | |
| 590 "Sec-WebSocket-Protocol: sample\r\n" | |
| 591 "Sec-WebSocket-Version: 13\r\n" | |
| 592 "\r\n"; | |
| 593 | |
| 594 const char WebSocketJobTest::kHandshakeRequestWithCookie[] = | |
| 595 "GET /demo HTTP/1.1\r\n" | |
| 596 "Host: example.com\r\n" | |
| 597 "Upgrade: WebSocket\r\n" | |
| 598 "Connection: Upgrade\r\n" | |
| 599 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 600 "Origin: http://example.com\r\n" | |
| 601 "Sec-WebSocket-Protocol: sample\r\n" | |
| 602 "Sec-WebSocket-Version: 13\r\n" | |
| 603 "Cookie: WK-test=1\r\n" | |
| 604 "\r\n"; | |
| 605 | |
| 606 const char WebSocketJobTest::kHandshakeRequestWithFilteredCookie[] = | |
| 607 "GET /demo HTTP/1.1\r\n" | |
| 608 "Host: example.com\r\n" | |
| 609 "Upgrade: WebSocket\r\n" | |
| 610 "Connection: Upgrade\r\n" | |
| 611 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 612 "Origin: http://example.com\r\n" | |
| 613 "Sec-WebSocket-Protocol: sample\r\n" | |
| 614 "Sec-WebSocket-Version: 13\r\n" | |
| 615 "Cookie: CR-test=1; CR-test-httponly=1\r\n" | |
| 616 "\r\n"; | |
| 617 | |
| 618 const char WebSocketJobTest::kHandshakeResponseWithoutCookie[] = | |
| 619 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 620 "Upgrade: websocket\r\n" | |
| 621 "Connection: Upgrade\r\n" | |
| 622 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 623 "Sec-WebSocket-Protocol: sample\r\n" | |
| 624 "\r\n"; | |
| 625 | |
| 626 const char WebSocketJobTest::kHandshakeResponseWithCookie[] = | |
| 627 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 628 "Upgrade: websocket\r\n" | |
| 629 "Connection: Upgrade\r\n" | |
| 630 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 631 "Sec-WebSocket-Protocol: sample\r\n" | |
| 632 "Set-Cookie: CR-set-test=1\r\n" | |
| 633 "\r\n"; | |
| 634 | |
| 635 const char WebSocketJobTest::kDataHello[] = "Hello, "; | |
| 636 | |
| 637 const char WebSocketJobTest::kDataWorld[] = "World!\n"; | |
| 638 | |
| 639 const size_t WebSocketJobTest::kHandshakeRequestWithoutCookieLength = | |
| 640 arraysize(kHandshakeRequestWithoutCookie) - 1; | |
| 641 const size_t WebSocketJobTest::kHandshakeRequestWithCookieLength = | |
| 642 arraysize(kHandshakeRequestWithCookie) - 1; | |
| 643 const size_t WebSocketJobTest::kHandshakeRequestWithFilteredCookieLength = | |
| 644 arraysize(kHandshakeRequestWithFilteredCookie) - 1; | |
| 645 const size_t WebSocketJobTest::kHandshakeResponseWithoutCookieLength = | |
| 646 arraysize(kHandshakeResponseWithoutCookie) - 1; | |
| 647 const size_t WebSocketJobTest::kHandshakeResponseWithCookieLength = | |
| 648 arraysize(kHandshakeResponseWithCookie) - 1; | |
| 649 const size_t WebSocketJobTest::kDataHelloLength = | |
| 650 arraysize(kDataHello) - 1; | |
| 651 const size_t WebSocketJobTest::kDataWorldLength = | |
| 652 arraysize(kDataWorld) - 1; | |
| 653 | |
| 654 void WebSocketJobTest::TestSimpleHandshake() { | |
| 655 GURL url("ws://example.com/demo"); | |
| 656 MockSocketStreamDelegate delegate; | |
| 657 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 658 SkipToConnecting(); | |
| 659 | |
| 660 DoSendRequest(); | |
| 661 base::MessageLoop::current()->RunUntilIdle(); | |
| 662 EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data()); | |
| 663 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 664 websocket_->OnSentData(socket_.get(), | |
| 665 kHandshakeRequestWithoutCookieLength); | |
| 666 EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent()); | |
| 667 | |
| 668 websocket_->OnReceivedData(socket_.get(), | |
| 669 kHandshakeResponseWithoutCookie, | |
| 670 kHandshakeResponseWithoutCookieLength); | |
| 671 base::MessageLoop::current()->RunUntilIdle(); | |
| 672 EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data()); | |
| 673 EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState()); | |
| 674 CloseWebSocketJob(); | |
| 675 } | |
| 676 | |
| 677 void WebSocketJobTest::TestSlowHandshake() { | |
| 678 GURL url("ws://example.com/demo"); | |
| 679 MockSocketStreamDelegate delegate; | |
| 680 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 681 SkipToConnecting(); | |
| 682 | |
| 683 DoSendRequest(); | |
| 684 // We assume request is sent in one data chunk (from WebKit) | |
| 685 // We don't support streaming request. | |
| 686 base::MessageLoop::current()->RunUntilIdle(); | |
| 687 EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data()); | |
| 688 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 689 websocket_->OnSentData(socket_.get(), | |
| 690 kHandshakeRequestWithoutCookieLength); | |
| 691 EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent()); | |
| 692 | |
| 693 std::vector<std::string> lines; | |
| 694 base::SplitString(kHandshakeResponseWithoutCookie, '\n', &lines); | |
| 695 for (size_t i = 0; i < lines.size() - 2; i++) { | |
| 696 std::string line = lines[i] + "\r\n"; | |
| 697 SCOPED_TRACE("Line: " + line); | |
| 698 websocket_->OnReceivedData(socket_.get(), line.c_str(), line.size()); | |
| 699 base::MessageLoop::current()->RunUntilIdle(); | |
| 700 EXPECT_TRUE(delegate.received_data().empty()); | |
| 701 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 702 } | |
| 703 websocket_->OnReceivedData(socket_.get(), "\r\n", 2); | |
| 704 base::MessageLoop::current()->RunUntilIdle(); | |
| 705 EXPECT_FALSE(delegate.received_data().empty()); | |
| 706 EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data()); | |
| 707 EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState()); | |
| 708 CloseWebSocketJob(); | |
| 709 } | |
| 710 | |
| 711 INSTANTIATE_TEST_CASE_P( | |
| 712 NextProto, | |
| 713 WebSocketJobTest, | |
| 714 testing::Values(kProtoDeprecatedSPDY2, | |
| 715 kProtoSPDY3, kProtoSPDY31, kProtoSPDY4)); | |
| 716 | |
| 717 TEST_P(WebSocketJobTest, DelayedCookies) { | |
| 718 enable_websocket_over_spdy_ = true; | |
| 719 GURL url("ws://example.com/demo"); | |
| 720 GURL cookieUrl("http://example.com/demo"); | |
| 721 CookieOptions cookie_options; | |
| 722 scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster(); | |
| 723 context_->set_cookie_store(cookie_store.get()); | |
| 724 cookie_store->SetCookieWithOptionsAsync(cookieUrl, | |
| 725 "CR-test=1", | |
| 726 cookie_options, | |
| 727 CookieMonster::SetCookiesCallback()); | |
| 728 cookie_options.set_include_httponly(); | |
| 729 cookie_store->SetCookieWithOptionsAsync( | |
| 730 cookieUrl, "CR-test-httponly=1", cookie_options, | |
| 731 CookieMonster::SetCookiesCallback()); | |
| 732 | |
| 733 MockSocketStreamDelegate delegate; | |
| 734 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 735 SkipToConnecting(); | |
| 736 | |
| 737 bool sent = websocket_->SendData(kHandshakeRequestWithCookie, | |
| 738 kHandshakeRequestWithCookieLength); | |
| 739 EXPECT_TRUE(sent); | |
| 740 base::MessageLoop::current()->RunUntilIdle(); | |
| 741 EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data()); | |
| 742 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 743 websocket_->OnSentData(socket_.get(), | |
| 744 kHandshakeRequestWithFilteredCookieLength); | |
| 745 EXPECT_EQ(kHandshakeRequestWithCookieLength, | |
| 746 delegate.amount_sent()); | |
| 747 | |
| 748 websocket_->OnReceivedData(socket_.get(), | |
| 749 kHandshakeResponseWithCookie, | |
| 750 kHandshakeResponseWithCookieLength); | |
| 751 base::MessageLoop::current()->RunUntilIdle(); | |
| 752 EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data()); | |
| 753 EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState()); | |
| 754 | |
| 755 CloseWebSocketJob(); | |
| 756 } | |
| 757 | |
| 758 void WebSocketJobTest::TestHandshakeWithCookie() { | |
| 759 GURL url("ws://example.com/demo"); | |
| 760 GURL cookieUrl("http://example.com/demo"); | |
| 761 CookieOptions cookie_options; | |
| 762 cookie_store_->SetCookieWithOptions( | |
| 763 cookieUrl, "CR-test=1", cookie_options); | |
| 764 cookie_options.set_include_httponly(); | |
| 765 cookie_store_->SetCookieWithOptions( | |
| 766 cookieUrl, "CR-test-httponly=1", cookie_options); | |
| 767 | |
| 768 MockSocketStreamDelegate delegate; | |
| 769 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 770 SkipToConnecting(); | |
| 771 | |
| 772 bool sent = websocket_->SendData(kHandshakeRequestWithCookie, | |
| 773 kHandshakeRequestWithCookieLength); | |
| 774 EXPECT_TRUE(sent); | |
| 775 base::MessageLoop::current()->RunUntilIdle(); | |
| 776 EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data()); | |
| 777 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 778 websocket_->OnSentData(socket_.get(), | |
| 779 kHandshakeRequestWithFilteredCookieLength); | |
| 780 EXPECT_EQ(kHandshakeRequestWithCookieLength, | |
| 781 delegate.amount_sent()); | |
| 782 | |
| 783 websocket_->OnReceivedData(socket_.get(), | |
| 784 kHandshakeResponseWithCookie, | |
| 785 kHandshakeResponseWithCookieLength); | |
| 786 base::MessageLoop::current()->RunUntilIdle(); | |
| 787 EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data()); | |
| 788 EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState()); | |
| 789 | |
| 790 EXPECT_EQ(3U, cookie_store_->entries().size()); | |
| 791 EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url); | |
| 792 EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line); | |
| 793 EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url); | |
| 794 EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line); | |
| 795 EXPECT_EQ(cookieUrl, cookie_store_->entries()[2].url); | |
| 796 EXPECT_EQ("CR-set-test=1", cookie_store_->entries()[2].cookie_line); | |
| 797 | |
| 798 CloseWebSocketJob(); | |
| 799 } | |
| 800 | |
| 801 void WebSocketJobTest::TestHandshakeWithCookieButNotAllowed() { | |
| 802 GURL url("ws://example.com/demo"); | |
| 803 GURL cookieUrl("http://example.com/demo"); | |
| 804 CookieOptions cookie_options; | |
| 805 cookie_store_->SetCookieWithOptions( | |
| 806 cookieUrl, "CR-test=1", cookie_options); | |
| 807 cookie_options.set_include_httponly(); | |
| 808 cookie_store_->SetCookieWithOptions( | |
| 809 cookieUrl, "CR-test-httponly=1", cookie_options); | |
| 810 | |
| 811 MockSocketStreamDelegate delegate; | |
| 812 delegate.set_allow_all_cookies(false); | |
| 813 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 814 SkipToConnecting(); | |
| 815 | |
| 816 bool sent = websocket_->SendData(kHandshakeRequestWithCookie, | |
| 817 kHandshakeRequestWithCookieLength); | |
| 818 EXPECT_TRUE(sent); | |
| 819 base::MessageLoop::current()->RunUntilIdle(); | |
| 820 EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data()); | |
| 821 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 822 websocket_->OnSentData(socket_.get(), kHandshakeRequestWithoutCookieLength); | |
| 823 EXPECT_EQ(kHandshakeRequestWithCookieLength, delegate.amount_sent()); | |
| 824 | |
| 825 websocket_->OnReceivedData(socket_.get(), | |
| 826 kHandshakeResponseWithCookie, | |
| 827 kHandshakeResponseWithCookieLength); | |
| 828 base::MessageLoop::current()->RunUntilIdle(); | |
| 829 EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data()); | |
| 830 EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState()); | |
| 831 | |
| 832 EXPECT_EQ(2U, cookie_store_->entries().size()); | |
| 833 EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url); | |
| 834 EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line); | |
| 835 EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url); | |
| 836 EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line); | |
| 837 | |
| 838 CloseWebSocketJob(); | |
| 839 } | |
| 840 | |
| 841 void WebSocketJobTest::TestHSTSUpgrade() { | |
| 842 GURL url("ws://upgrademe.com/"); | |
| 843 MockSocketStreamDelegate delegate; | |
| 844 scoped_refptr<SocketStreamJob> job = | |
| 845 SocketStreamJob::CreateSocketStreamJob( | |
| 846 url, &delegate, context_->transport_security_state(), | |
| 847 context_->ssl_config_service(), NULL, NULL); | |
| 848 EXPECT_TRUE(GetSocket(job.get())->is_secure()); | |
| 849 job->DetachDelegate(); | |
| 850 | |
| 851 url = GURL("ws://donotupgrademe.com/"); | |
| 852 job = SocketStreamJob::CreateSocketStreamJob( | |
| 853 url, &delegate, context_->transport_security_state(), | |
| 854 context_->ssl_config_service(), NULL, NULL); | |
| 855 EXPECT_FALSE(GetSocket(job.get())->is_secure()); | |
| 856 job->DetachDelegate(); | |
| 857 } | |
| 858 | |
| 859 void WebSocketJobTest::TestInvalidSendData() { | |
| 860 GURL url("ws://example.com/demo"); | |
| 861 MockSocketStreamDelegate delegate; | |
| 862 InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET); | |
| 863 SkipToConnecting(); | |
| 864 | |
| 865 DoSendRequest(); | |
| 866 // We assume request is sent in one data chunk (from WebKit) | |
| 867 // We don't support streaming request. | |
| 868 base::MessageLoop::current()->RunUntilIdle(); | |
| 869 EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data()); | |
| 870 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 871 websocket_->OnSentData(socket_.get(), | |
| 872 kHandshakeRequestWithoutCookieLength); | |
| 873 EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent()); | |
| 874 | |
| 875 // We could not send any data until connection is established. | |
| 876 bool sent = websocket_->SendData(kHandshakeRequestWithoutCookie, | |
| 877 kHandshakeRequestWithoutCookieLength); | |
| 878 EXPECT_FALSE(sent); | |
| 879 EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState()); | |
| 880 CloseWebSocketJob(); | |
| 881 } | |
| 882 | |
| 883 // Following tests verify cooperation between WebSocketJob and SocketStream. | |
| 884 // Other former tests use MockSocketStream as SocketStream, so we could not | |
| 885 // check SocketStream behavior. | |
| 886 // OrderedSocketData provide socket level verifiation by checking out-going | |
| 887 // packets in comparison with the MockWrite array and emulating in-coming | |
| 888 // packets with MockRead array. | |
| 889 | |
| 890 void WebSocketJobTest::TestConnectByWebSocket( | |
| 891 ThrottlingOption throttling) { | |
| 892 // This is a test for verifying cooperation between WebSocketJob and | |
| 893 // SocketStream. If |throttling| was |THROTTLING_OFF|, it test basic | |
| 894 // situation. If |throttling| was |THROTTLING_ON|, throttling limits the | |
| 895 // latter connection. | |
| 896 MockWrite writes[] = { | |
| 897 MockWrite(ASYNC, | |
| 898 kHandshakeRequestWithoutCookie, | |
| 899 kHandshakeRequestWithoutCookieLength, | |
| 900 1), | |
| 901 MockWrite(ASYNC, | |
| 902 kDataHello, | |
| 903 kDataHelloLength, | |
| 904 3) | |
| 905 }; | |
| 906 MockRead reads[] = { | |
| 907 MockRead(ASYNC, | |
| 908 kHandshakeResponseWithoutCookie, | |
| 909 kHandshakeResponseWithoutCookieLength, | |
| 910 2), | |
| 911 MockRead(ASYNC, | |
| 912 kDataWorld, | |
| 913 kDataWorldLength, | |
| 914 4), | |
| 915 MockRead(SYNCHRONOUS, 0, 5) // EOF | |
| 916 }; | |
| 917 data_.reset(new OrderedSocketData( | |
| 918 reads, arraysize(reads), writes, arraysize(writes))); | |
| 919 | |
| 920 GURL url("ws://example.com/demo"); | |
| 921 MockSocketStreamDelegate delegate; | |
| 922 WebSocketJobTest* test = this; | |
| 923 if (throttling == THROTTLING_ON) | |
| 924 delegate.SetOnStartOpenConnection( | |
| 925 base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test))); | |
| 926 delegate.SetOnConnected( | |
| 927 base::Bind(&WebSocketJobTest::DoSendRequest, | |
| 928 base::Unretained(test))); | |
| 929 delegate.SetOnReceivedData( | |
| 930 base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test))); | |
| 931 delegate.SetOnClose( | |
| 932 base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test))); | |
| 933 InitWebSocketJob(url, &delegate, STREAM_SOCKET); | |
| 934 | |
| 935 scoped_refptr<WebSocketJob> block_websocket; | |
| 936 if (throttling == THROTTLING_ON) { | |
| 937 // Create former WebSocket object which obstructs the latter one. | |
| 938 block_websocket = new WebSocketJob(NULL); | |
| 939 block_websocket->addresses_ = AddressList(websocket_->address_list()); | |
| 940 ASSERT_TRUE( | |
| 941 WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get())); | |
| 942 } | |
| 943 | |
| 944 websocket_->Connect(); | |
| 945 | |
| 946 if (throttling == THROTTLING_ON) { | |
| 947 EXPECT_EQ(OK, WaitForResult()); | |
| 948 EXPECT_TRUE(websocket_->IsWaiting()); | |
| 949 | |
| 950 // Remove the former WebSocket object from throttling queue to unblock the | |
| 951 // latter. | |
| 952 block_websocket->state_ = WebSocketJob::CLOSED; | |
| 953 WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get()); | |
| 954 block_websocket = NULL; | |
| 955 } | |
| 956 | |
| 957 EXPECT_EQ(OK, WaitForResult()); | |
| 958 EXPECT_TRUE(data_->at_read_eof()); | |
| 959 EXPECT_TRUE(data_->at_write_eof()); | |
| 960 EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState()); | |
| 961 } | |
| 962 | |
| 963 void WebSocketJobTest::TestConnectBySpdy( | |
| 964 SpdyOption spdy, ThrottlingOption throttling) { | |
| 965 // This is a test for verifying cooperation between WebSocketJob and | |
| 966 // SocketStream in the situation we have SPDY session to the server. If | |
| 967 // |throttling| was |THROTTLING_ON|, throttling limits the latter connection. | |
| 968 // If you enabled spdy, you should specify |spdy| as |SPDY_ON|. Expected | |
| 969 // results depend on its configuration. | |
| 970 MockWrite writes_websocket[] = { | |
| 971 MockWrite(ASYNC, | |
| 972 kHandshakeRequestWithoutCookie, | |
| 973 kHandshakeRequestWithoutCookieLength, | |
| 974 1), | |
| 975 MockWrite(ASYNC, | |
| 976 kDataHello, | |
| 977 kDataHelloLength, | |
| 978 3) | |
| 979 }; | |
| 980 MockRead reads_websocket[] = { | |
| 981 MockRead(ASYNC, | |
| 982 kHandshakeResponseWithoutCookie, | |
| 983 kHandshakeResponseWithoutCookieLength, | |
| 984 2), | |
| 985 MockRead(ASYNC, | |
| 986 kDataWorld, | |
| 987 kDataWorldLength, | |
| 988 4), | |
| 989 MockRead(SYNCHRONOUS, 0, 5) // EOF | |
| 990 }; | |
| 991 | |
| 992 scoped_ptr<SpdyHeaderBlock> request_headers(new SpdyHeaderBlock()); | |
| 993 spdy_util_.SetHeader("path", "/demo", request_headers.get()); | |
| 994 spdy_util_.SetHeader("version", "WebSocket/13", request_headers.get()); | |
| 995 spdy_util_.SetHeader("scheme", "ws", request_headers.get()); | |
| 996 spdy_util_.SetHeader("host", "example.com", request_headers.get()); | |
| 997 spdy_util_.SetHeader("origin", "http://example.com", request_headers.get()); | |
| 998 spdy_util_.SetHeader("sec-websocket-protocol", "sample", | |
| 999 request_headers.get()); | |
| 1000 | |
| 1001 scoped_ptr<SpdyHeaderBlock> response_headers(new SpdyHeaderBlock()); | |
| 1002 spdy_util_.SetHeader("status", "101 Switching Protocols", | |
| 1003 response_headers.get()); | |
| 1004 spdy_util_.SetHeader("sec-websocket-protocol", "sample", | |
| 1005 response_headers.get()); | |
| 1006 | |
| 1007 const SpdyStreamId kStreamId = 1; | |
| 1008 scoped_ptr<SpdyFrame> request_frame( | |
| 1009 spdy_util_.ConstructSpdyWebSocketHandshakeRequestFrame( | |
| 1010 request_headers.Pass(), | |
| 1011 kStreamId, | |
| 1012 MEDIUM)); | |
| 1013 scoped_ptr<SpdyFrame> response_frame( | |
| 1014 spdy_util_.ConstructSpdyWebSocketHandshakeResponseFrame( | |
| 1015 response_headers.Pass(), | |
| 1016 kStreamId, | |
| 1017 MEDIUM)); | |
| 1018 scoped_ptr<SpdyFrame> data_hello_frame( | |
| 1019 spdy_util_.ConstructSpdyWebSocketDataFrame( | |
| 1020 kDataHello, | |
| 1021 kDataHelloLength, | |
| 1022 kStreamId, | |
| 1023 false)); | |
| 1024 scoped_ptr<SpdyFrame> data_world_frame( | |
| 1025 spdy_util_.ConstructSpdyWebSocketDataFrame( | |
| 1026 kDataWorld, | |
| 1027 kDataWorldLength, | |
| 1028 kStreamId, | |
| 1029 false)); | |
| 1030 MockWrite writes_spdy[] = { | |
| 1031 CreateMockWrite(*request_frame.get(), 1), | |
| 1032 CreateMockWrite(*data_hello_frame.get(), 3), | |
| 1033 }; | |
| 1034 MockRead reads_spdy[] = { | |
| 1035 CreateMockRead(*response_frame.get(), 2), | |
| 1036 CreateMockRead(*data_world_frame.get(), 4), | |
| 1037 MockRead(SYNCHRONOUS, 0, 5) // EOF | |
| 1038 }; | |
| 1039 | |
| 1040 if (spdy == SPDY_ON) | |
| 1041 data_.reset(new OrderedSocketData( | |
| 1042 reads_spdy, arraysize(reads_spdy), | |
| 1043 writes_spdy, arraysize(writes_spdy))); | |
| 1044 else | |
| 1045 data_.reset(new OrderedSocketData( | |
| 1046 reads_websocket, arraysize(reads_websocket), | |
| 1047 writes_websocket, arraysize(writes_websocket))); | |
| 1048 | |
| 1049 GURL url("ws://example.com/demo"); | |
| 1050 MockSocketStreamDelegate delegate; | |
| 1051 WebSocketJobTest* test = this; | |
| 1052 if (throttling == THROTTLING_ON) | |
| 1053 delegate.SetOnStartOpenConnection( | |
| 1054 base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test))); | |
| 1055 delegate.SetOnConnected( | |
| 1056 base::Bind(&WebSocketJobTest::DoSendRequest, | |
| 1057 base::Unretained(test))); | |
| 1058 delegate.SetOnReceivedData( | |
| 1059 base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test))); | |
| 1060 delegate.SetOnClose( | |
| 1061 base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test))); | |
| 1062 InitWebSocketJob(url, &delegate, STREAM_SPDY_WEBSOCKET); | |
| 1063 | |
| 1064 scoped_refptr<WebSocketJob> block_websocket; | |
| 1065 if (throttling == THROTTLING_ON) { | |
| 1066 // Create former WebSocket object which obstructs the latter one. | |
| 1067 block_websocket = new WebSocketJob(NULL); | |
| 1068 block_websocket->addresses_ = AddressList(websocket_->address_list()); | |
| 1069 ASSERT_TRUE( | |
| 1070 WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get())); | |
| 1071 } | |
| 1072 | |
| 1073 websocket_->Connect(); | |
| 1074 | |
| 1075 if (throttling == THROTTLING_ON) { | |
| 1076 EXPECT_EQ(OK, WaitForResult()); | |
| 1077 EXPECT_TRUE(websocket_->IsWaiting()); | |
| 1078 | |
| 1079 // Remove the former WebSocket object from throttling queue to unblock the | |
| 1080 // latter. | |
| 1081 block_websocket->state_ = WebSocketJob::CLOSED; | |
| 1082 WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get()); | |
| 1083 block_websocket = NULL; | |
| 1084 } | |
| 1085 | |
| 1086 EXPECT_EQ(OK, WaitForResult()); | |
| 1087 EXPECT_TRUE(data_->at_read_eof()); | |
| 1088 EXPECT_TRUE(data_->at_write_eof()); | |
| 1089 EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState()); | |
| 1090 } | |
| 1091 | |
| 1092 void WebSocketJobTest::TestThrottlingLimit() { | |
| 1093 std::vector<scoped_refptr<WebSocketJob> > jobs; | |
| 1094 const int kMaxWebSocketJobsThrottled = 1024; | |
| 1095 IPAddressNumber ip; | |
| 1096 ParseIPLiteralToNumber("127.0.0.1", &ip); | |
| 1097 for (int i = 0; i < kMaxWebSocketJobsThrottled + 1; ++i) { | |
| 1098 scoped_refptr<WebSocketJob> job = new WebSocketJob(NULL); | |
| 1099 job->addresses_ = AddressList(AddressList::CreateFromIPAddress(ip, 80)); | |
| 1100 if (i >= kMaxWebSocketJobsThrottled) | |
| 1101 EXPECT_FALSE(WebSocketThrottle::GetInstance()->PutInQueue(job.get())); | |
| 1102 else | |
| 1103 EXPECT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(job.get())); | |
| 1104 jobs.push_back(job); | |
| 1105 } | |
| 1106 | |
| 1107 // Close the jobs in reverse order. Otherwise, We need to make them prepared | |
| 1108 // for Wakeup call. | |
| 1109 for (std::vector<scoped_refptr<WebSocketJob> >::reverse_iterator iter = | |
| 1110 jobs.rbegin(); | |
| 1111 iter != jobs.rend(); | |
| 1112 ++iter) { | |
| 1113 WebSocketJob* job = (*iter).get(); | |
| 1114 job->state_ = WebSocketJob::CLOSED; | |
| 1115 WebSocketThrottle::GetInstance()->RemoveFromQueue(job); | |
| 1116 } | |
| 1117 } | |
| 1118 | |
| 1119 // Execute tests in both spdy-disabled mode and spdy-enabled mode. | |
| 1120 TEST_P(WebSocketJobTest, SimpleHandshake) { | |
| 1121 TestSimpleHandshake(); | |
| 1122 } | |
| 1123 | |
| 1124 TEST_P(WebSocketJobTest, SlowHandshake) { | |
| 1125 TestSlowHandshake(); | |
| 1126 } | |
| 1127 | |
| 1128 TEST_P(WebSocketJobTest, HandshakeWithCookie) { | |
| 1129 TestHandshakeWithCookie(); | |
| 1130 } | |
| 1131 | |
| 1132 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowed) { | |
| 1133 TestHandshakeWithCookieButNotAllowed(); | |
| 1134 } | |
| 1135 | |
| 1136 TEST_P(WebSocketJobTest, HSTSUpgrade) { | |
| 1137 TestHSTSUpgrade(); | |
| 1138 } | |
| 1139 | |
| 1140 TEST_P(WebSocketJobTest, InvalidSendData) { | |
| 1141 TestInvalidSendData(); | |
| 1142 } | |
| 1143 | |
| 1144 TEST_P(WebSocketJobTest, SimpleHandshakeSpdyEnabled) { | |
| 1145 enable_websocket_over_spdy_ = true; | |
| 1146 TestSimpleHandshake(); | |
| 1147 } | |
| 1148 | |
| 1149 TEST_P(WebSocketJobTest, SlowHandshakeSpdyEnabled) { | |
| 1150 enable_websocket_over_spdy_ = true; | |
| 1151 TestSlowHandshake(); | |
| 1152 } | |
| 1153 | |
| 1154 TEST_P(WebSocketJobTest, HandshakeWithCookieSpdyEnabled) { | |
| 1155 enable_websocket_over_spdy_ = true; | |
| 1156 TestHandshakeWithCookie(); | |
| 1157 } | |
| 1158 | |
| 1159 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowedSpdyEnabled) { | |
| 1160 enable_websocket_over_spdy_ = true; | |
| 1161 TestHandshakeWithCookieButNotAllowed(); | |
| 1162 } | |
| 1163 | |
| 1164 TEST_P(WebSocketJobTest, HSTSUpgradeSpdyEnabled) { | |
| 1165 enable_websocket_over_spdy_ = true; | |
| 1166 TestHSTSUpgrade(); | |
| 1167 } | |
| 1168 | |
| 1169 TEST_P(WebSocketJobTest, InvalidSendDataSpdyEnabled) { | |
| 1170 enable_websocket_over_spdy_ = true; | |
| 1171 TestInvalidSendData(); | |
| 1172 } | |
| 1173 | |
| 1174 TEST_P(WebSocketJobTest, ConnectByWebSocket) { | |
| 1175 enable_websocket_over_spdy_ = true; | |
| 1176 TestConnectByWebSocket(THROTTLING_OFF); | |
| 1177 } | |
| 1178 | |
| 1179 TEST_P(WebSocketJobTest, ConnectByWebSocketSpdyEnabled) { | |
| 1180 enable_websocket_over_spdy_ = true; | |
| 1181 TestConnectByWebSocket(THROTTLING_OFF); | |
| 1182 } | |
| 1183 | |
| 1184 TEST_P(WebSocketJobTest, ConnectBySpdy) { | |
| 1185 TestConnectBySpdy(SPDY_OFF, THROTTLING_OFF); | |
| 1186 } | |
| 1187 | |
| 1188 TEST_P(WebSocketJobTest, ConnectBySpdySpdyEnabled) { | |
| 1189 enable_websocket_over_spdy_ = true; | |
| 1190 TestConnectBySpdy(SPDY_ON, THROTTLING_OFF); | |
| 1191 } | |
| 1192 | |
| 1193 TEST_P(WebSocketJobTest, ThrottlingWebSocket) { | |
| 1194 TestConnectByWebSocket(THROTTLING_ON); | |
| 1195 } | |
| 1196 | |
| 1197 TEST_P(WebSocketJobTest, ThrottlingMaxNumberOfThrottledJobLimit) { | |
| 1198 TestThrottlingLimit(); | |
| 1199 } | |
| 1200 | |
| 1201 TEST_P(WebSocketJobTest, ThrottlingWebSocketSpdyEnabled) { | |
| 1202 enable_websocket_over_spdy_ = true; | |
| 1203 TestConnectByWebSocket(THROTTLING_ON); | |
| 1204 } | |
| 1205 | |
| 1206 TEST_P(WebSocketJobTest, ThrottlingSpdy) { | |
| 1207 TestConnectBySpdy(SPDY_OFF, THROTTLING_ON); | |
| 1208 } | |
| 1209 | |
| 1210 TEST_P(WebSocketJobTest, ThrottlingSpdySpdyEnabled) { | |
| 1211 enable_websocket_over_spdy_ = true; | |
| 1212 TestConnectBySpdy(SPDY_ON, THROTTLING_ON); | |
| 1213 } | |
| 1214 | |
| 1215 TEST_F(WebSocketJobDeleteTest, OnClose) { | |
| 1216 SetDeleteNext(); | |
| 1217 job()->OnClose(socket_.get()); | |
| 1218 // OnClose() sets WebSocketJob::_socket to NULL before we can detach it, so | |
| 1219 // socket_->delegate is still set at this point. Clear it to avoid hitting | |
| 1220 // DCHECK(!delegate_) in the SocketStream destructor. SocketStream::Finish() | |
| 1221 // is the only caller of this method in real code, and it also sets delegate_ | |
| 1222 // to NULL. | |
| 1223 socket_->DetachDelegate(); | |
| 1224 EXPECT_FALSE(job()); | |
| 1225 } | |
| 1226 | |
| 1227 TEST_F(WebSocketJobDeleteTest, OnAuthRequired) { | |
| 1228 SetDeleteNext(); | |
| 1229 job()->OnAuthRequired(socket_.get(), NULL); | |
| 1230 EXPECT_FALSE(job()); | |
| 1231 } | |
| 1232 | |
| 1233 TEST_F(WebSocketJobDeleteTest, OnSSLCertificateError) { | |
| 1234 SSLInfo ssl_info; | |
| 1235 SetDeleteNext(); | |
| 1236 job()->OnSSLCertificateError(socket_.get(), ssl_info, true); | |
| 1237 EXPECT_FALSE(job()); | |
| 1238 } | |
| 1239 | |
| 1240 TEST_F(WebSocketJobDeleteTest, OnError) { | |
| 1241 SetDeleteNext(); | |
| 1242 job()->OnError(socket_.get(), ERR_CONNECTION_RESET); | |
| 1243 EXPECT_FALSE(job()); | |
| 1244 } | |
| 1245 | |
| 1246 TEST_F(WebSocketJobDeleteTest, OnSentSpdyHeaders) { | |
| 1247 job()->Connect(); | |
| 1248 SetDeleteNext(); | |
| 1249 job()->OnSentSpdyHeaders(); | |
| 1250 EXPECT_FALSE(job()); | |
| 1251 } | |
| 1252 | |
| 1253 TEST_F(WebSocketJobDeleteTest, OnSentHandshakeRequest) { | |
| 1254 static const char kMinimalRequest[] = | |
| 1255 "GET /demo HTTP/1.1\r\n" | |
| 1256 "Host: example.com\r\n" | |
| 1257 "Upgrade: WebSocket\r\n" | |
| 1258 "Connection: Upgrade\r\n" | |
| 1259 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n" | |
| 1260 "Origin: http://example.com\r\n" | |
| 1261 "Sec-WebSocket-Version: 13\r\n" | |
| 1262 "\r\n"; | |
| 1263 const size_t kMinimalRequestSize = arraysize(kMinimalRequest) - 1; | |
| 1264 job()->Connect(); | |
| 1265 job()->SendData(kMinimalRequest, kMinimalRequestSize); | |
| 1266 SetDeleteNext(); | |
| 1267 job()->OnSentData(socket_.get(), kMinimalRequestSize); | |
| 1268 EXPECT_FALSE(job()); | |
| 1269 } | |
| 1270 | |
| 1271 TEST_F(WebSocketJobDeleteTest, NotifyHeadersComplete) { | |
| 1272 static const char kMinimalResponse[] = | |
| 1273 "HTTP/1.1 101 Switching Protocols\r\n" | |
| 1274 "Upgrade: websocket\r\n" | |
| 1275 "Connection: Upgrade\r\n" | |
| 1276 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n" | |
| 1277 "\r\n"; | |
| 1278 job()->Connect(); | |
| 1279 SetDeleteNext(); | |
| 1280 job()->OnReceivedData( | |
| 1281 socket_.get(), kMinimalResponse, arraysize(kMinimalResponse) - 1); | |
| 1282 EXPECT_FALSE(job()); | |
| 1283 } | |
| 1284 | |
| 1285 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation. | |
| 1286 // TODO(toyoshim,yutak): Add tests to verify closing handshake. | |
| 1287 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 723343002:
Update from https://crrev.com/304121 (Closed)
Base URL: git@github.com:domokit/mojo.git@master