| 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 "chrome/browser/extensions/api/cast_channel/cast_socket.h" | |
| 6 | |
| 7 #include "base/message_loop/message_loop.h" | |
| 8 #include "base/run_loop.h" | |
| 9 #include "base/strings/string_number_conversions.h" | |
| 10 #include "base/sys_byteorder.h" | |
| 11 #include "chrome/browser/extensions/api/cast_channel/cast_channel.pb.h" | |
| 12 #include "chrome/browser/extensions/api/cast_channel/cast_message_util.h" | |
| 13 #include "net/base/address_list.h" | |
| 14 #include "net/base/capturing_net_log.h" | |
| 15 #include "net/base/net_errors.h" | |
| 16 #include "net/base/net_util.h" | |
| 17 #include "net/socket/socket_test_util.h" | |
| 18 #include "net/socket/ssl_client_socket.h" | |
| 19 #include "net/socket/tcp_client_socket.h" | |
| 20 #include "net/ssl/ssl_info.h" | |
| 21 #include "testing/gmock/include/gmock/gmock.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 | |
| 24 using ::testing::_; | |
| 25 using ::testing::A; | |
| 26 using ::testing::DoAll; | |
| 27 using ::testing::Return; | |
| 28 using ::testing::SaveArg; | |
| 29 | |
| 30 namespace { | |
| 31 const char* kTestData[4] = { | |
| 32 "Hello, World!", | |
| 33 "Goodbye, World!", | |
| 34 "Hello, Sky!", | |
| 35 "Goodbye, Volcano!", | |
| 36 }; | |
| 37 } // namespace | |
| 38 | |
| 39 namespace extensions { | |
| 40 namespace api { | |
| 41 namespace cast_channel { | |
| 42 | |
| 43 // Fills in |message| with a string message. | |
| 44 static void CreateStringMessage(const std::string& namespace_, | |
| 45 const std::string& source_id, | |
| 46 const std::string& destination_id, | |
| 47 const std::string& data, | |
| 48 MessageInfo* message) { | |
| 49 message->namespace_ = namespace_; | |
| 50 message->source_id = source_id; | |
| 51 message->destination_id = destination_id; | |
| 52 message->data.reset(new base::StringValue(data)); | |
| 53 } | |
| 54 | |
| 55 // Fills in |message| with a binary message. | |
| 56 static void CreateBinaryMessage(const std::string& namespace_, | |
| 57 const std::string& source_id, | |
| 58 const std::string& destination_id, | |
| 59 const std::string& data, | |
| 60 MessageInfo* message) { | |
| 61 message->namespace_ = namespace_; | |
| 62 message->source_id = source_id; | |
| 63 message->destination_id = destination_id; | |
| 64 message->data.reset(base::BinaryValue::CreateWithCopiedBuffer( | |
| 65 data.c_str(), data.size())); | |
| 66 } | |
| 67 | |
| 68 class MockCastSocketDelegate : public CastSocket::Delegate { | |
| 69 public: | |
| 70 MOCK_METHOD2(OnError, void(const CastSocket* socket, | |
| 71 ChannelError error)); | |
| 72 MOCK_METHOD2(OnMessage, void(const CastSocket* socket, | |
| 73 const MessageInfo& message)); | |
| 74 }; | |
| 75 | |
| 76 class MockTCPSocket : public net::TCPClientSocket { | |
| 77 public: | |
| 78 explicit MockTCPSocket(const net::MockConnect& connect_data) : | |
| 79 TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()), | |
| 80 connect_data_(connect_data) { } | |
| 81 | |
| 82 virtual int Connect(const net::CompletionCallback& callback) OVERRIDE { | |
| 83 if (connect_data_.mode == net::ASYNC) { | |
| 84 CHECK_NE(connect_data_.result, net::ERR_IO_PENDING); | |
| 85 base::MessageLoop::current()->PostTask( | |
| 86 FROM_HERE, | |
| 87 base::Bind(callback, connect_data_.result)); | |
| 88 return net::ERR_IO_PENDING; | |
| 89 } else { | |
| 90 return connect_data_.result; | |
| 91 } | |
| 92 } | |
| 93 | |
| 94 virtual bool SetKeepAlive(bool enable, int delay) OVERRIDE { | |
| 95 // Always return true in tests | |
| 96 return true; | |
| 97 } | |
| 98 | |
| 99 virtual bool SetNoDelay(bool no_delay) OVERRIDE { | |
| 100 // Always return true in tests | |
| 101 return true; | |
| 102 } | |
| 103 | |
| 104 MOCK_METHOD3(Read, | |
| 105 int(net::IOBuffer*, int, const net::CompletionCallback&)); | |
| 106 MOCK_METHOD3(Write, | |
| 107 int(net::IOBuffer*, int, const net::CompletionCallback&)); | |
| 108 | |
| 109 virtual void Disconnect() OVERRIDE { | |
| 110 // Do nothing in tests | |
| 111 } | |
| 112 | |
| 113 private: | |
| 114 net::MockConnect connect_data_; | |
| 115 }; | |
| 116 | |
| 117 class CompleteHandler { | |
| 118 public: | |
| 119 CompleteHandler() {} | |
| 120 MOCK_METHOD1(OnCloseComplete, void(int result)); | |
| 121 MOCK_METHOD1(OnConnectComplete, void(int result)); | |
| 122 MOCK_METHOD1(OnWriteComplete, void(int result)); | |
| 123 private: | |
| 124 DISALLOW_COPY_AND_ASSIGN(CompleteHandler); | |
| 125 }; | |
| 126 | |
| 127 class TestCastSocket : public CastSocket { | |
| 128 public: | |
| 129 static scoped_ptr<TestCastSocket> Create( | |
| 130 MockCastSocketDelegate* delegate) { | |
| 131 return scoped_ptr<TestCastSocket>( | |
| 132 new TestCastSocket(delegate, CreateIPEndPoint(), | |
| 133 CHANNEL_AUTH_TYPE_SSL)); | |
| 134 } | |
| 135 | |
| 136 static scoped_ptr<TestCastSocket> CreateSecure( | |
| 137 MockCastSocketDelegate* delegate) { | |
| 138 return scoped_ptr<TestCastSocket>( | |
| 139 new TestCastSocket(delegate, CreateIPEndPoint(), | |
| 140 CHANNEL_AUTH_TYPE_SSL_VERIFIED)); | |
| 141 } | |
| 142 | |
| 143 explicit TestCastSocket(MockCastSocketDelegate* delegate, | |
| 144 const net::IPEndPoint& ip_endpoint, | |
| 145 ChannelAuthType channel_auth) : | |
| 146 CastSocket("abcdefg", ip_endpoint, channel_auth, delegate, | |
| 147 &capturing_net_log_), | |
| 148 ip_(ip_endpoint), | |
| 149 connect_index_(0), | |
| 150 extract_cert_result_(true), | |
| 151 verify_challenge_result_(true) { | |
| 152 } | |
| 153 | |
| 154 static net::IPEndPoint CreateIPEndPoint() { | |
| 155 net::IPAddressNumber number; | |
| 156 number.push_back(192); | |
| 157 number.push_back(0); | |
| 158 number.push_back(0); | |
| 159 number.push_back(1); | |
| 160 return net::IPEndPoint(number, 8009); | |
| 161 } | |
| 162 | |
| 163 // Returns the size of the body (in bytes) of the given serialized message. | |
| 164 static size_t ComputeBodySize(const std::string& msg) { | |
| 165 return msg.length() - CastSocket::MessageHeader::header_size(); | |
| 166 } | |
| 167 | |
| 168 virtual ~TestCastSocket() { | |
| 169 } | |
| 170 | |
| 171 // Helpers to set mock results for various operations. | |
| 172 void SetupTcp1Connect(net::IoMode mode, int result) { | |
| 173 tcp_connect_data_[0].reset(new net::MockConnect(mode, result)); | |
| 174 } | |
| 175 void SetupSsl1Connect(net::IoMode mode, int result) { | |
| 176 ssl_connect_data_[0].reset(new net::MockConnect(mode, result)); | |
| 177 } | |
| 178 void SetupTcp2Connect(net::IoMode mode, int result) { | |
| 179 tcp_connect_data_[1].reset(new net::MockConnect(mode, result)); | |
| 180 } | |
| 181 void SetupSsl2Connect(net::IoMode mode, int result) { | |
| 182 ssl_connect_data_[1].reset(new net::MockConnect(mode, result)); | |
| 183 } | |
| 184 void AddWriteResult(const net::MockWrite& write) { | |
| 185 writes_.push_back(write); | |
| 186 } | |
| 187 void AddWriteResult(net::IoMode mode, int result) { | |
| 188 AddWriteResult(net::MockWrite(mode, result)); | |
| 189 } | |
| 190 void AddWriteResultForMessage(net::IoMode mode, const std::string& msg) { | |
| 191 AddWriteResult(mode, msg.size()); | |
| 192 } | |
| 193 void AddWriteResultForMessage(net::IoMode mode, | |
| 194 const std::string& msg, | |
| 195 size_t ch_size) { | |
| 196 size_t msg_size = msg.size(); | |
| 197 for (size_t offset = 0; offset < msg_size; offset += ch_size) { | |
| 198 if (offset + ch_size > msg_size) | |
| 199 ch_size = msg_size - offset; | |
| 200 AddWriteResult(mode, ch_size); | |
| 201 } | |
| 202 } | |
| 203 | |
| 204 void AddReadResult(const net::MockRead& read) { | |
| 205 reads_.push_back(read); | |
| 206 } | |
| 207 void AddReadResult(net::IoMode mode, int result) { | |
| 208 AddReadResult(net::MockRead(mode, result)); | |
| 209 } | |
| 210 void AddReadResult(net::IoMode mode, const char* data, int data_len) { | |
| 211 AddReadResult(net::MockRead(mode, data, data_len)); | |
| 212 } | |
| 213 void AddReadResultForMessage(net::IoMode mode, const std::string& msg) { | |
| 214 size_t body_size = ComputeBodySize(msg); | |
| 215 const char* data = msg.c_str(); | |
| 216 AddReadResult(mode, data, MessageHeader::header_size()); | |
| 217 AddReadResult(mode, data + MessageHeader::header_size(), body_size); | |
| 218 } | |
| 219 void AddReadResultForMessage(net::IoMode mode, | |
| 220 const std::string& msg, | |
| 221 size_t ch_size) { | |
| 222 size_t msg_size = msg.size(); | |
| 223 const char* data = msg.c_str(); | |
| 224 for (size_t offset = 0; offset < msg_size; offset += ch_size) { | |
| 225 if (offset + ch_size > msg_size) | |
| 226 ch_size = msg_size - offset; | |
| 227 AddReadResult(mode, data + offset, ch_size); | |
| 228 } | |
| 229 } | |
| 230 | |
| 231 void SetExtractCertResult(bool value) { | |
| 232 extract_cert_result_ = value; | |
| 233 } | |
| 234 void SetVerifyChallengeResult(bool value) { | |
| 235 verify_challenge_result_ = value; | |
| 236 } | |
| 237 | |
| 238 private: | |
| 239 virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE { | |
| 240 net::MockConnect* connect_data = tcp_connect_data_[connect_index_].get(); | |
| 241 connect_data->peer_addr = ip_; | |
| 242 return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(*connect_data)); | |
| 243 } | |
| 244 | |
| 245 virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket( | |
| 246 scoped_ptr<net::StreamSocket> socket) OVERRIDE { | |
| 247 net::MockConnect* connect_data = ssl_connect_data_[connect_index_].get(); | |
| 248 connect_data->peer_addr = ip_; | |
| 249 ++connect_index_; | |
| 250 | |
| 251 ssl_data_.reset(new net::StaticSocketDataProvider( | |
| 252 reads_.data(), reads_.size(), writes_.data(), writes_.size())); | |
| 253 ssl_data_->set_connect_data(*connect_data); | |
| 254 // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !! | |
| 255 return scoped_ptr<net::SSLClientSocket>( | |
| 256 new net::MockTCPClientSocket( | |
| 257 net::AddressList(), &capturing_net_log_, ssl_data_.get())); | |
| 258 } | |
| 259 | |
| 260 virtual bool ExtractPeerCert(std::string* cert) OVERRIDE { | |
| 261 if (extract_cert_result_) | |
| 262 cert->assign("dummy_test_cert"); | |
| 263 return extract_cert_result_; | |
| 264 } | |
| 265 | |
| 266 virtual bool VerifyChallengeReply() OVERRIDE { | |
| 267 return verify_challenge_result_; | |
| 268 } | |
| 269 | |
| 270 net::CapturingNetLog capturing_net_log_; | |
| 271 net::IPEndPoint ip_; | |
| 272 // Simulated connect data | |
| 273 scoped_ptr<net::MockConnect> tcp_connect_data_[2]; | |
| 274 scoped_ptr<net::MockConnect> ssl_connect_data_[2]; | |
| 275 // Simulated read / write data | |
| 276 std::vector<net::MockWrite> writes_; | |
| 277 std::vector<net::MockRead> reads_; | |
| 278 scoped_ptr<net::SocketDataProvider> ssl_data_; | |
| 279 // Number of times Connect method is called | |
| 280 size_t connect_index_; | |
| 281 // Simulated result of peer cert extraction. | |
| 282 bool extract_cert_result_; | |
| 283 // Simulated result of verifying challenge reply. | |
| 284 bool verify_challenge_result_; | |
| 285 }; | |
| 286 | |
| 287 class CastSocketTest : public testing::Test { | |
| 288 public: | |
| 289 CastSocketTest() {} | |
| 290 virtual ~CastSocketTest() {} | |
| 291 | |
| 292 virtual void SetUp() OVERRIDE { | |
| 293 // Create a few test messages | |
| 294 for (size_t i = 0; i < arraysize(test_messages_); i++) { | |
| 295 CreateStringMessage("urn:cast", "1", "2", kTestData[i], | |
| 296 &test_messages_[i]); | |
| 297 ASSERT_TRUE(MessageInfoToCastMessage( | |
| 298 test_messages_[i], &test_protos_[i])); | |
| 299 ASSERT_TRUE(CastSocket::Serialize(test_protos_[i], &test_proto_strs_[i])); | |
| 300 } | |
| 301 | |
| 302 // Create a test auth request. | |
| 303 CastMessage request; | |
| 304 CreateAuthChallengeMessage(&request); | |
| 305 ASSERT_TRUE(CastSocket::Serialize(request, &auth_request_)); | |
| 306 | |
| 307 // Create a test auth reply. | |
| 308 MessageInfo reply; | |
| 309 CreateBinaryMessage("urn:x-cast:com.google.cast.tp.deviceauth", | |
| 310 "sender-0", | |
| 311 "receiver-0", | |
| 312 "abcd", | |
| 313 &reply); | |
| 314 CastMessage reply_msg; | |
| 315 ASSERT_TRUE(MessageInfoToCastMessage(reply, &reply_msg)); | |
| 316 ASSERT_TRUE(CastSocket::Serialize(reply_msg, &auth_reply_)); | |
| 317 } | |
| 318 | |
| 319 virtual void TearDown() OVERRIDE { | |
| 320 EXPECT_CALL(handler_, OnCloseComplete(net::OK)); | |
| 321 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete, | |
| 322 base::Unretained(&handler_))); | |
| 323 } | |
| 324 | |
| 325 void CreateCastSocket() { | |
| 326 socket_ = TestCastSocket::Create(&mock_delegate_); | |
| 327 } | |
| 328 | |
| 329 void CreateCastSocketSecure() { | |
| 330 socket_ = TestCastSocket::CreateSecure(&mock_delegate_); | |
| 331 } | |
| 332 | |
| 333 // Sets up CastSocket::Connect to succeed. | |
| 334 // Connecting the socket also starts the read loop; so we add a mock | |
| 335 // read result that returns IO_PENDING and callback is never fired. | |
| 336 void ConnectHelper() { | |
| 337 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 338 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK); | |
| 339 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 340 | |
| 341 EXPECT_CALL(handler_, OnConnectComplete(net::OK)); | |
| 342 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 343 base::Unretained(&handler_))); | |
| 344 RunPendingTasks(); | |
| 345 } | |
| 346 | |
| 347 protected: | |
| 348 // Runs all pending tasks in the message loop. | |
| 349 void RunPendingTasks() { | |
| 350 base::RunLoop run_loop; | |
| 351 run_loop.RunUntilIdle(); | |
| 352 } | |
| 353 | |
| 354 base::MessageLoop message_loop_; | |
| 355 MockCastSocketDelegate mock_delegate_; | |
| 356 scoped_ptr<TestCastSocket> socket_; | |
| 357 CompleteHandler handler_; | |
| 358 MessageInfo test_messages_[arraysize(kTestData)]; | |
| 359 CastMessage test_protos_[arraysize(kTestData)]; | |
| 360 std::string test_proto_strs_[arraysize(kTestData)]; | |
| 361 std::string auth_request_; | |
| 362 std::string auth_reply_; | |
| 363 }; | |
| 364 | |
| 365 // Tests connecting and closing the socket. | |
| 366 TEST_F(CastSocketTest, TestConnectAndClose) { | |
| 367 CreateCastSocket(); | |
| 368 ConnectHelper(); | |
| 369 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 370 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 371 | |
| 372 EXPECT_CALL(handler_, OnCloseComplete(net::OK)); | |
| 373 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete, | |
| 374 base::Unretained(&handler_))); | |
| 375 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 376 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 377 } | |
| 378 | |
| 379 // Tests that the following connection flow works: | |
| 380 // - TCP connection succeeds (async) | |
| 381 // - SSL connection succeeds (async) | |
| 382 TEST_F(CastSocketTest, TestConnect) { | |
| 383 CreateCastSocket(); | |
| 384 socket_->SetupTcp1Connect(net::ASYNC, net::OK); | |
| 385 socket_->SetupSsl1Connect(net::ASYNC, net::OK); | |
| 386 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 387 | |
| 388 EXPECT_CALL(handler_, OnConnectComplete(net::OK)); | |
| 389 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 390 base::Unretained(&handler_))); | |
| 391 RunPendingTasks(); | |
| 392 | |
| 393 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 394 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 395 } | |
| 396 | |
| 397 // Test that the following connection flow works: | |
| 398 // - TCP connection succeeds (async) | |
| 399 // - SSL connection fails with cert error (async) | |
| 400 // - Cert is extracted successfully | |
| 401 // - Second TCP connection succeeds (async) | |
| 402 // - Second SSL connection succeeds (async) | |
| 403 TEST_F(CastSocketTest, TestConnectTwoStep) { | |
| 404 CreateCastSocket(); | |
| 405 socket_->SetupTcp1Connect(net::ASYNC, net::OK); | |
| 406 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID); | |
| 407 socket_->SetupTcp2Connect(net::ASYNC, net::OK); | |
| 408 socket_->SetupSsl2Connect(net::ASYNC, net::OK); | |
| 409 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 410 | |
| 411 EXPECT_CALL(handler_, OnConnectComplete(net::OK)); | |
| 412 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 413 base::Unretained(&handler_))); | |
| 414 RunPendingTasks(); | |
| 415 | |
| 416 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 417 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 418 } | |
| 419 | |
| 420 // Test that the following connection flow works: | |
| 421 // - TCP connection succeeds (async) | |
| 422 // - SSL connection fails with cert error (async) | |
| 423 // - Cert is extracted successfully | |
| 424 // - Second TCP connection succeeds (async) | |
| 425 // - Second SSL connection fails (async) | |
| 426 // - The flow should NOT be tried again | |
| 427 TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) { | |
| 428 CreateCastSocket(); | |
| 429 socket_->SetupTcp1Connect(net::ASYNC, net::OK); | |
| 430 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID); | |
| 431 socket_->SetupTcp2Connect(net::ASYNC, net::OK); | |
| 432 socket_->SetupSsl2Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID); | |
| 433 | |
| 434 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID)); | |
| 435 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 436 base::Unretained(&handler_))); | |
| 437 RunPendingTasks(); | |
| 438 | |
| 439 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 440 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 441 } | |
| 442 | |
| 443 // Tests that the following connection flow works: | |
| 444 // - TCP connection succeeds (async) | |
| 445 // - SSL connection fails with cert error (async) | |
| 446 // - Cert is extracted successfully | |
| 447 // - Second TCP connection succeeds (async) | |
| 448 // - Second SSL connection succeeds (async) | |
| 449 // - Challenge request is sent (async) | |
| 450 // - Challenge response is received (async) | |
| 451 // - Credentials are verified successfuly | |
| 452 TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) { | |
| 453 CreateCastSocketSecure(); | |
| 454 | |
| 455 socket_->SetupTcp1Connect(net::ASYNC, net::OK); | |
| 456 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID); | |
| 457 socket_->SetupTcp2Connect(net::ASYNC, net::OK); | |
| 458 socket_->SetupSsl2Connect(net::ASYNC, net::OK); | |
| 459 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_); | |
| 460 socket_->AddReadResultForMessage(net::ASYNC, auth_reply_); | |
| 461 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 462 | |
| 463 EXPECT_CALL(handler_, OnConnectComplete(net::OK)); | |
| 464 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 465 base::Unretained(&handler_))); | |
| 466 RunPendingTasks(); | |
| 467 | |
| 468 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 469 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 470 } | |
| 471 | |
| 472 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous. | |
| 473 TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) { | |
| 474 CreateCastSocketSecure(); | |
| 475 | |
| 476 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 477 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID); | |
| 478 socket_->SetupTcp2Connect(net::SYNCHRONOUS, net::OK); | |
| 479 socket_->SetupSsl2Connect(net::SYNCHRONOUS, net::OK); | |
| 480 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, auth_request_); | |
| 481 socket_->AddReadResultForMessage(net::SYNCHRONOUS, auth_reply_); | |
| 482 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 483 | |
| 484 EXPECT_CALL(handler_, OnConnectComplete(net::OK)); | |
| 485 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 486 base::Unretained(&handler_))); | |
| 487 RunPendingTasks(); | |
| 488 | |
| 489 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 490 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 491 } | |
| 492 | |
| 493 // Test connection error - TCP connect fails (async) | |
| 494 TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) { | |
| 495 CreateCastSocketSecure(); | |
| 496 | |
| 497 socket_->SetupTcp1Connect(net::ASYNC, net::ERR_FAILED); | |
| 498 | |
| 499 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 500 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 501 base::Unretained(&handler_))); | |
| 502 RunPendingTasks(); | |
| 503 | |
| 504 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 505 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 506 } | |
| 507 | |
| 508 // Test connection error - TCP connect fails (sync) | |
| 509 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) { | |
| 510 CreateCastSocketSecure(); | |
| 511 | |
| 512 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::ERR_FAILED); | |
| 513 | |
| 514 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 515 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 516 base::Unretained(&handler_))); | |
| 517 RunPendingTasks(); | |
| 518 | |
| 519 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 520 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 521 } | |
| 522 | |
| 523 // Test connection error - SSL connect fails (async) | |
| 524 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) { | |
| 525 CreateCastSocketSecure(); | |
| 526 | |
| 527 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 528 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_FAILED); | |
| 529 | |
| 530 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 531 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 532 base::Unretained(&handler_))); | |
| 533 RunPendingTasks(); | |
| 534 | |
| 535 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 536 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 537 } | |
| 538 | |
| 539 // Test connection error - SSL connect fails (async) | |
| 540 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) { | |
| 541 CreateCastSocketSecure(); | |
| 542 | |
| 543 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 544 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_FAILED); | |
| 545 | |
| 546 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 547 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 548 base::Unretained(&handler_))); | |
| 549 RunPendingTasks(); | |
| 550 | |
| 551 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 552 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 553 } | |
| 554 | |
| 555 // Test connection error - cert extraction error (async) | |
| 556 TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) { | |
| 557 CreateCastSocket(); | |
| 558 socket_->SetupTcp1Connect(net::ASYNC, net::OK); | |
| 559 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID); | |
| 560 // Set cert extraction to fail | |
| 561 socket_->SetExtractCertResult(false); | |
| 562 | |
| 563 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID)); | |
| 564 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 565 base::Unretained(&handler_))); | |
| 566 RunPendingTasks(); | |
| 567 | |
| 568 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 569 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 570 } | |
| 571 | |
| 572 // Test connection error - cert extraction error (sync) | |
| 573 TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) { | |
| 574 CreateCastSocket(); | |
| 575 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 576 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID); | |
| 577 // Set cert extraction to fail | |
| 578 socket_->SetExtractCertResult(false); | |
| 579 | |
| 580 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID)); | |
| 581 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 582 base::Unretained(&handler_))); | |
| 583 RunPendingTasks(); | |
| 584 | |
| 585 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 586 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 587 } | |
| 588 | |
| 589 // Test connection error - challenge send fails | |
| 590 TEST_F(CastSocketTest, TestConnectChallengeSendError) { | |
| 591 CreateCastSocketSecure(); | |
| 592 | |
| 593 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 594 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK); | |
| 595 socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED); | |
| 596 | |
| 597 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 598 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 599 base::Unretained(&handler_))); | |
| 600 RunPendingTasks(); | |
| 601 | |
| 602 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 603 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 604 } | |
| 605 | |
| 606 // Test connection error - challenge reply receive fails | |
| 607 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) { | |
| 608 CreateCastSocketSecure(); | |
| 609 | |
| 610 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 611 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK); | |
| 612 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_); | |
| 613 socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED); | |
| 614 | |
| 615 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 616 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 617 base::Unretained(&handler_))); | |
| 618 RunPendingTasks(); | |
| 619 | |
| 620 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 621 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 622 } | |
| 623 | |
| 624 // Test connection error - challenge reply verification fails | |
| 625 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) { | |
| 626 CreateCastSocketSecure(); | |
| 627 | |
| 628 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK); | |
| 629 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK); | |
| 630 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_); | |
| 631 socket_->AddReadResultForMessage(net::ASYNC, auth_reply_); | |
| 632 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); | |
| 633 socket_->SetVerifyChallengeResult(false); | |
| 634 | |
| 635 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED)); | |
| 636 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete, | |
| 637 base::Unretained(&handler_))); | |
| 638 RunPendingTasks(); | |
| 639 | |
| 640 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 641 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); | |
| 642 } | |
| 643 | |
| 644 // Test write success - single message (async) | |
| 645 TEST_F(CastSocketTest, TestWriteAsync) { | |
| 646 CreateCastSocket(); | |
| 647 socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0]); | |
| 648 ConnectHelper(); | |
| 649 | |
| 650 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size())); | |
| 651 socket_->SendMessage(test_messages_[0], | |
| 652 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 653 base::Unretained(&handler_))); | |
| 654 RunPendingTasks(); | |
| 655 | |
| 656 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 657 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 658 } | |
| 659 | |
| 660 // Test write success - single message (sync) | |
| 661 TEST_F(CastSocketTest, TestWriteSync) { | |
| 662 CreateCastSocket(); | |
| 663 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]); | |
| 664 ConnectHelper(); | |
| 665 | |
| 666 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size())); | |
| 667 socket_->SendMessage(test_messages_[0], | |
| 668 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 669 base::Unretained(&handler_))); | |
| 670 RunPendingTasks(); | |
| 671 | |
| 672 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 673 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 674 } | |
| 675 | |
| 676 // Test write success - single message sent in multiple chunks (async) | |
| 677 TEST_F(CastSocketTest, TestWriteChunkedAsync) { | |
| 678 CreateCastSocket(); | |
| 679 socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0], 2); | |
| 680 ConnectHelper(); | |
| 681 | |
| 682 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size())); | |
| 683 socket_->SendMessage(test_messages_[0], | |
| 684 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 685 base::Unretained(&handler_))); | |
| 686 RunPendingTasks(); | |
| 687 | |
| 688 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 689 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 690 } | |
| 691 | |
| 692 // Test write success - single message sent in multiple chunks (sync) | |
| 693 TEST_F(CastSocketTest, TestWriteChunkedSync) { | |
| 694 CreateCastSocket(); | |
| 695 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2); | |
| 696 ConnectHelper(); | |
| 697 | |
| 698 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size())); | |
| 699 socket_->SendMessage(test_messages_[0], | |
| 700 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 701 base::Unretained(&handler_))); | |
| 702 RunPendingTasks(); | |
| 703 | |
| 704 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 705 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 706 } | |
| 707 | |
| 708 // Test write success - multiple messages (async) | |
| 709 TEST_F(CastSocketTest, TestWriteManyAsync) { | |
| 710 CreateCastSocket(); | |
| 711 for (size_t i = 0; i < arraysize(test_messages_); i++) { | |
| 712 size_t msg_size = test_proto_strs_[i].size(); | |
| 713 socket_->AddWriteResult(net::ASYNC, msg_size); | |
| 714 EXPECT_CALL(handler_, OnWriteComplete(msg_size)); | |
| 715 } | |
| 716 ConnectHelper(); | |
| 717 | |
| 718 for (size_t i = 0; i < arraysize(test_messages_); i++) { | |
| 719 socket_->SendMessage(test_messages_[i], | |
| 720 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 721 base::Unretained(&handler_))); | |
| 722 } | |
| 723 RunPendingTasks(); | |
| 724 | |
| 725 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 726 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 727 } | |
| 728 | |
| 729 // Test write success - multiple messages (sync) | |
| 730 TEST_F(CastSocketTest, TestWriteManySync) { | |
| 731 CreateCastSocket(); | |
| 732 for (size_t i = 0; i < arraysize(test_messages_); i++) { | |
| 733 size_t msg_size = test_proto_strs_[i].size(); | |
| 734 socket_->AddWriteResult(net::SYNCHRONOUS, msg_size); | |
| 735 EXPECT_CALL(handler_, OnWriteComplete(msg_size)); | |
| 736 } | |
| 737 ConnectHelper(); | |
| 738 | |
| 739 for (size_t i = 0; i < arraysize(test_messages_); i++) { | |
| 740 socket_->SendMessage(test_messages_[i], | |
| 741 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 742 base::Unretained(&handler_))); | |
| 743 } | |
| 744 RunPendingTasks(); | |
| 745 | |
| 746 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 747 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 748 } | |
| 749 | |
| 750 // Test write error - not connected | |
| 751 TEST_F(CastSocketTest, TestWriteErrorNotConnected) { | |
| 752 CreateCastSocket(); | |
| 753 | |
| 754 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED)); | |
| 755 socket_->SendMessage(test_messages_[0], | |
| 756 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 757 base::Unretained(&handler_))); | |
| 758 | |
| 759 EXPECT_EQ(cast_channel::READY_STATE_NONE, socket_->ready_state()); | |
| 760 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 761 } | |
| 762 | |
| 763 // Test write error - very large message | |
| 764 TEST_F(CastSocketTest, TestWriteErrorLargeMessage) { | |
| 765 CreateCastSocket(); | |
| 766 ConnectHelper(); | |
| 767 | |
| 768 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED)); | |
| 769 size_t size = CastSocket::MessageHeader::max_message_size() + 1; | |
| 770 test_messages_[0].data.reset( | |
| 771 new base::StringValue(std::string(size, 'a'))); | |
| 772 socket_->SendMessage(test_messages_[0], | |
| 773 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 774 base::Unretained(&handler_))); | |
| 775 | |
| 776 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 777 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 778 | |
| 779 } | |
| 780 | |
| 781 // Test write error - network error (sync) | |
| 782 TEST_F(CastSocketTest, TestWriteNetworkErrorSync) { | |
| 783 CreateCastSocket(); | |
| 784 socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED); | |
| 785 ConnectHelper(); | |
| 786 | |
| 787 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED)); | |
| 788 EXPECT_CALL(mock_delegate_, | |
| 789 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 790 socket_->SendMessage(test_messages_[0], | |
| 791 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 792 base::Unretained(&handler_))); | |
| 793 RunPendingTasks(); | |
| 794 | |
| 795 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 796 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 797 } | |
| 798 | |
| 799 // Test write error - network error (async) | |
| 800 TEST_F(CastSocketTest, TestWriteErrorAsync) { | |
| 801 CreateCastSocket(); | |
| 802 socket_->AddWriteResult(net::ASYNC, net::ERR_FAILED); | |
| 803 ConnectHelper(); | |
| 804 | |
| 805 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED)); | |
| 806 EXPECT_CALL(mock_delegate_, | |
| 807 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 808 socket_->SendMessage(test_messages_[0], | |
| 809 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 810 base::Unretained(&handler_))); | |
| 811 RunPendingTasks(); | |
| 812 | |
| 813 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 814 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 815 } | |
| 816 | |
| 817 // Test write error - 0 bytes written should be considered an error | |
| 818 TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) { | |
| 819 CreateCastSocket(); | |
| 820 socket_->AddWriteResult(net::SYNCHRONOUS, 0); | |
| 821 ConnectHelper(); | |
| 822 | |
| 823 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED)); | |
| 824 EXPECT_CALL(mock_delegate_, | |
| 825 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 826 socket_->SendMessage(test_messages_[0], | |
| 827 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 828 base::Unretained(&handler_))); | |
| 829 RunPendingTasks(); | |
| 830 | |
| 831 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 832 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 833 } | |
| 834 | |
| 835 // Test that when an error occurrs in one write, write callback is invoked for | |
| 836 // all pending writes with the error | |
| 837 TEST_F(CastSocketTest, TestWriteErrorWithMultiplePendingWritesAsync) { | |
| 838 CreateCastSocket(); | |
| 839 socket_->AddWriteResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED); | |
| 840 ConnectHelper(); | |
| 841 | |
| 842 const int num_writes = arraysize(test_messages_); | |
| 843 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED)) | |
| 844 .Times(num_writes); | |
| 845 EXPECT_CALL(mock_delegate_, | |
| 846 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 847 for (int i = 0; i < num_writes; i++) { | |
| 848 socket_->SendMessage(test_messages_[i], | |
| 849 base::Bind(&CompleteHandler::OnWriteComplete, | |
| 850 base::Unretained(&handler_))); | |
| 851 } | |
| 852 RunPendingTasks(); | |
| 853 | |
| 854 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 855 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 856 } | |
| 857 | |
| 858 // Test read success - single message (async) | |
| 859 TEST_F(CastSocketTest, TestReadAsync) { | |
| 860 CreateCastSocket(); | |
| 861 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0]); | |
| 862 EXPECT_CALL(mock_delegate_, | |
| 863 OnMessage(socket_.get(), A<const MessageInfo&>())); | |
| 864 ConnectHelper(); | |
| 865 | |
| 866 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 867 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 868 } | |
| 869 | |
| 870 // Test read success - single message (sync) | |
| 871 TEST_F(CastSocketTest, TestReadSync) { | |
| 872 CreateCastSocket(); | |
| 873 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]); | |
| 874 EXPECT_CALL(mock_delegate_, | |
| 875 OnMessage(socket_.get(), A<const MessageInfo&>())); | |
| 876 ConnectHelper(); | |
| 877 | |
| 878 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 879 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 880 } | |
| 881 | |
| 882 // Test read success - single message received in multiple chunks (async) | |
| 883 TEST_F(CastSocketTest, TestReadChunkedAsync) { | |
| 884 CreateCastSocket(); | |
| 885 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0], 2); | |
| 886 EXPECT_CALL(mock_delegate_, | |
| 887 OnMessage(socket_.get(), A<const MessageInfo&>())); | |
| 888 ConnectHelper(); | |
| 889 | |
| 890 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 891 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 892 } | |
| 893 | |
| 894 // Test read success - single message received in multiple chunks (sync) | |
| 895 TEST_F(CastSocketTest, TestReadChunkedSync) { | |
| 896 CreateCastSocket(); | |
| 897 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2); | |
| 898 EXPECT_CALL(mock_delegate_, | |
| 899 OnMessage(socket_.get(), A<const MessageInfo&>())); | |
| 900 ConnectHelper(); | |
| 901 | |
| 902 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 903 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 904 } | |
| 905 | |
| 906 // Test read success - multiple messages (async) | |
| 907 TEST_F(CastSocketTest, TestReadManyAsync) { | |
| 908 CreateCastSocket(); | |
| 909 size_t num_reads = arraysize(test_proto_strs_); | |
| 910 for (size_t i = 0; i < num_reads; i++) | |
| 911 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[i]); | |
| 912 EXPECT_CALL(mock_delegate_, | |
| 913 OnMessage(socket_.get(), A<const MessageInfo&>())) | |
| 914 .Times(num_reads); | |
| 915 ConnectHelper(); | |
| 916 | |
| 917 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 918 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 919 } | |
| 920 | |
| 921 // Test read success - multiple messages (sync) | |
| 922 TEST_F(CastSocketTest, TestReadManySync) { | |
| 923 CreateCastSocket(); | |
| 924 size_t num_reads = arraysize(test_proto_strs_); | |
| 925 for (size_t i = 0; i < num_reads; i++) | |
| 926 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[i]); | |
| 927 EXPECT_CALL(mock_delegate_, | |
| 928 OnMessage(socket_.get(), A<const MessageInfo&>())) | |
| 929 .Times(num_reads); | |
| 930 ConnectHelper(); | |
| 931 | |
| 932 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); | |
| 933 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); | |
| 934 } | |
| 935 | |
| 936 // Test read error - network error (async) | |
| 937 TEST_F(CastSocketTest, TestReadErrorAsync) { | |
| 938 CreateCastSocket(); | |
| 939 socket_->AddReadResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED); | |
| 940 EXPECT_CALL(mock_delegate_, | |
| 941 OnError(socket_.get(), | |
| 942 cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 943 ConnectHelper(); | |
| 944 | |
| 945 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 946 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 947 } | |
| 948 | |
| 949 // Test read error - network error (sync) | |
| 950 TEST_F(CastSocketTest, TestReadErrorSync) { | |
| 951 CreateCastSocket(); | |
| 952 socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_SOCKET_NOT_CONNECTED); | |
| 953 EXPECT_CALL(mock_delegate_, | |
| 954 OnError(socket_.get(), | |
| 955 cast_channel::CHANNEL_ERROR_SOCKET_ERROR)); | |
| 956 ConnectHelper(); | |
| 957 | |
| 958 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 959 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); | |
| 960 } | |
| 961 | |
| 962 // Test read error - header parse error | |
| 963 TEST_F(CastSocketTest, TestReadHeaderParseError) { | |
| 964 CreateCastSocket(); | |
| 965 uint32 body_size = base::HostToNet32( | |
| 966 CastSocket::MessageHeader::max_message_size() + 1); | |
| 967 // TODO(munjal): Add a method to cast_message_util.h to serialize messages | |
| 968 char header[sizeof(body_size)]; | |
| 969 memcpy(&header, &body_size, arraysize(header)); | |
| 970 socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header)); | |
| 971 EXPECT_CALL(mock_delegate_, | |
| 972 OnError(socket_.get(), | |
| 973 cast_channel::CHANNEL_ERROR_INVALID_MESSAGE)); | |
| 974 ConnectHelper(); | |
| 975 | |
| 976 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 977 EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE, | |
| 978 socket_->error_state()); | |
| 979 } | |
| 980 | |
| 981 // Test read error - body parse error | |
| 982 TEST_F(CastSocketTest, TestReadBodyParseError) { | |
| 983 CreateCastSocket(); | |
| 984 char body[] = "some body"; | |
| 985 uint32 body_size = base::HostToNet32(arraysize(body)); | |
| 986 char header[sizeof(body_size)]; | |
| 987 memcpy(&header, &body_size, arraysize(header)); | |
| 988 socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header)); | |
| 989 socket_->AddReadResult(net::SYNCHRONOUS, body, arraysize(body)); | |
| 990 EXPECT_CALL(mock_delegate_, | |
| 991 OnError(socket_.get(), | |
| 992 cast_channel::CHANNEL_ERROR_INVALID_MESSAGE)); | |
| 993 ConnectHelper(); | |
| 994 | |
| 995 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); | |
| 996 EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE, | |
| 997 socket_->error_state()); | |
| 998 } | |
| 999 | |
| 1000 } // namespace cast_channel | |
| 1001 } // namespace api | |
| 1002 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 395333003:
Extensions: Move cast_channel and hid APIs to extensions/. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src