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.
CreateStringMessage(const std::string & namespace_,const std::string & source_id,const std::string & destination_id,const std::string & data,MessageInfo * 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.
CreateBinaryMessage(const std::string & namespace_,const std::string & source_id,const std::string & destination_id,const std::string & data,MessageInfo * 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:
MockTCPSocket(const net::MockConnect & connect_data)78 explicit MockTCPSocket(const net::MockConnect& connect_data) :
79 TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()),
80 connect_data_(connect_data) { }
81
Connect(const net::CompletionCallback & callback)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
SetKeepAlive(bool enable,int delay)94 virtual bool SetKeepAlive(bool enable, int delay) OVERRIDE {
95 // Always return true in tests
96 return true;
97 }
98
SetNoDelay(bool no_delay)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
Disconnect()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:
CompleteHandler()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:
Create(MockCastSocketDelegate * delegate)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
CreateSecure(MockCastSocketDelegate * delegate)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
TestCastSocket(MockCastSocketDelegate * delegate,const net::IPEndPoint & ip_endpoint,ChannelAuthType channel_auth)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 verify_challenge_disallow_(false) {
153 }
154
CreateIPEndPoint()155 static net::IPEndPoint CreateIPEndPoint() {
156 net::IPAddressNumber number;
157 number.push_back(192);
158 number.push_back(0);
159 number.push_back(0);
160 number.push_back(1);
161 return net::IPEndPoint(number, 8009);
162 }
163
164 // Returns the size of the body (in bytes) of the given serialized message.
ComputeBodySize(const std::string & msg)165 static size_t ComputeBodySize(const std::string& msg) {
166 return msg.length() - CastSocket::MessageHeader::header_size();
167 }
168
~TestCastSocket()169 virtual ~TestCastSocket() {
170 }
171
172 // Helpers to set mock results for various operations.
SetupTcp1Connect(net::IoMode mode,int result)173 void SetupTcp1Connect(net::IoMode mode, int result) {
174 tcp_connect_data_[0].reset(new net::MockConnect(mode, result));
175 }
SetupSsl1Connect(net::IoMode mode,int result)176 void SetupSsl1Connect(net::IoMode mode, int result) {
177 ssl_connect_data_[0].reset(new net::MockConnect(mode, result));
178 }
SetupTcp2Connect(net::IoMode mode,int result)179 void SetupTcp2Connect(net::IoMode mode, int result) {
180 tcp_connect_data_[1].reset(new net::MockConnect(mode, result));
181 }
SetupSsl2Connect(net::IoMode mode,int result)182 void SetupSsl2Connect(net::IoMode mode, int result) {
183 ssl_connect_data_[1].reset(new net::MockConnect(mode, result));
184 }
AddWriteResult(const net::MockWrite & write)185 void AddWriteResult(const net::MockWrite& write) {
186 writes_.push_back(write);
187 }
AddWriteResult(net::IoMode mode,int result)188 void AddWriteResult(net::IoMode mode, int result) {
189 AddWriteResult(net::MockWrite(mode, result));
190 }
AddWriteResultForMessage(net::IoMode mode,const std::string & msg)191 void AddWriteResultForMessage(net::IoMode mode, const std::string& msg) {
192 AddWriteResult(mode, msg.size());
193 }
AddWriteResultForMessage(net::IoMode mode,const std::string & msg,size_t ch_size)194 void AddWriteResultForMessage(net::IoMode mode,
195 const std::string& msg,
196 size_t ch_size) {
197 size_t msg_size = msg.size();
198 for (size_t offset = 0; offset < msg_size; offset += ch_size) {
199 if (offset + ch_size > msg_size)
200 ch_size = msg_size - offset;
201 AddWriteResult(mode, ch_size);
202 }
203 }
204
AddReadResult(const net::MockRead & read)205 void AddReadResult(const net::MockRead& read) {
206 reads_.push_back(read);
207 }
AddReadResult(net::IoMode mode,int result)208 void AddReadResult(net::IoMode mode, int result) {
209 AddReadResult(net::MockRead(mode, result));
210 }
AddReadResult(net::IoMode mode,const char * data,int data_len)211 void AddReadResult(net::IoMode mode, const char* data, int data_len) {
212 AddReadResult(net::MockRead(mode, data, data_len));
213 }
AddReadResultForMessage(net::IoMode mode,const std::string & msg)214 void AddReadResultForMessage(net::IoMode mode, const std::string& msg) {
215 size_t body_size = ComputeBodySize(msg);
216 const char* data = msg.c_str();
217 AddReadResult(mode, data, MessageHeader::header_size());
218 AddReadResult(mode, data + MessageHeader::header_size(), body_size);
219 }
AddReadResultForMessage(net::IoMode mode,const std::string & msg,size_t ch_size)220 void AddReadResultForMessage(net::IoMode mode,
221 const std::string& msg,
222 size_t ch_size) {
223 size_t msg_size = msg.size();
224 const char* data = msg.c_str();
225 for (size_t offset = 0; offset < msg_size; offset += ch_size) {
226 if (offset + ch_size > msg_size)
227 ch_size = msg_size - offset;
228 AddReadResult(mode, data + offset, ch_size);
229 }
230 }
231
SetExtractCertResult(bool value)232 void SetExtractCertResult(bool value) {
233 extract_cert_result_ = value;
234 }
SetVerifyChallengeResult(bool value)235 void SetVerifyChallengeResult(bool value) {
236 verify_challenge_result_ = value;
237 }
238
DisallowVerifyChallengeResult()239 void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }
240
241 private:
CreateTcpSocket()242 virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE {
243 net::MockConnect* connect_data = tcp_connect_data_[connect_index_].get();
244 connect_data->peer_addr = ip_;
245 return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(*connect_data));
246 }
247
CreateSslSocket(scoped_ptr<net::StreamSocket> socket)248 virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket(
249 scoped_ptr<net::StreamSocket> socket) OVERRIDE {
250 net::MockConnect* connect_data = ssl_connect_data_[connect_index_].get();
251 connect_data->peer_addr = ip_;
252 ++connect_index_;
253
254 ssl_data_.reset(new net::StaticSocketDataProvider(
255 reads_.data(), reads_.size(), writes_.data(), writes_.size()));
256 ssl_data_->set_connect_data(*connect_data);
257 // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
258 return scoped_ptr<net::SSLClientSocket>(
259 new net::MockTCPClientSocket(
260 net::AddressList(), &capturing_net_log_, ssl_data_.get()));
261 }
262
ExtractPeerCert(std::string * cert)263 virtual bool ExtractPeerCert(std::string* cert) OVERRIDE {
264 if (extract_cert_result_)
265 cert->assign("dummy_test_cert");
266 return extract_cert_result_;
267 }
268
VerifyChallengeReply()269 virtual bool VerifyChallengeReply() OVERRIDE {
270 EXPECT_FALSE(verify_challenge_disallow_);
271 return verify_challenge_result_;
272 }
273
274 net::CapturingNetLog capturing_net_log_;
275 net::IPEndPoint ip_;
276 // Simulated connect data
277 scoped_ptr<net::MockConnect> tcp_connect_data_[2];
278 scoped_ptr<net::MockConnect> ssl_connect_data_[2];
279 // Simulated read / write data
280 std::vector<net::MockWrite> writes_;
281 std::vector<net::MockRead> reads_;
282 scoped_ptr<net::SocketDataProvider> ssl_data_;
283 // Number of times Connect method is called
284 size_t connect_index_;
285 // Simulated result of peer cert extraction.
286 bool extract_cert_result_;
287 // Simulated result of verifying challenge reply.
288 bool verify_challenge_result_;
289 bool verify_challenge_disallow_;
290 };
291
292 class CastSocketTest : public testing::Test {
293 public:
CastSocketTest()294 CastSocketTest() {}
~CastSocketTest()295 virtual ~CastSocketTest() {}
296
SetUp()297 virtual void SetUp() OVERRIDE {
298 // Create a few test messages
299 for (size_t i = 0; i < arraysize(test_messages_); i++) {
300 CreateStringMessage("urn:cast", "1", "2", kTestData[i],
301 &test_messages_[i]);
302 ASSERT_TRUE(MessageInfoToCastMessage(
303 test_messages_[i], &test_protos_[i]));
304 ASSERT_TRUE(CastSocket::Serialize(test_protos_[i], &test_proto_strs_[i]));
305 }
306 }
307
TearDown()308 virtual void TearDown() OVERRIDE {
309 EXPECT_CALL(handler_, OnCloseComplete(net::OK));
310 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
311 base::Unretained(&handler_)));
312 }
313
314 // The caller can specify non-standard namespaces by setting "auth_namespace"
315 // (useful for negative test cases.)
SetupAuthMessage(const char * auth_namespace="urn:x-cast:com.google.cast.tp.deviceauth")316 void SetupAuthMessage(
317 const char* auth_namespace = "urn:x-cast:com.google.cast.tp.deviceauth") {
318 // Create a test auth request.
319 CastMessage request;
320 CreateAuthChallengeMessage(&request);
321 ASSERT_TRUE(CastSocket::Serialize(request, &auth_request_));
322
323 // Create a test auth reply.
324 MessageInfo reply;
325 CreateBinaryMessage(
326 auth_namespace, "sender-0", "receiver-0", "abcd", &reply);
327 CastMessage reply_msg;
328 ASSERT_TRUE(MessageInfoToCastMessage(reply, &reply_msg));
329 ASSERT_TRUE(CastSocket::Serialize(reply_msg, &auth_reply_));
330 }
331
CreateCastSocket()332 void CreateCastSocket() {
333 socket_ = TestCastSocket::Create(&mock_delegate_);
334 }
335
CreateCastSocketSecure()336 void CreateCastSocketSecure() {
337 socket_ = TestCastSocket::CreateSecure(&mock_delegate_);
338 }
339
340 // Sets up CastSocket::Connect to succeed.
341 // Connecting the socket also starts the read loop; so we add a mock
342 // read result that returns IO_PENDING and callback is never fired.
ConnectHelper()343 void ConnectHelper() {
344 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
345 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
346 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
347
348 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
349 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
350 base::Unretained(&handler_)));
351 RunPendingTasks();
352 }
353
354 protected:
355 // Runs all pending tasks in the message loop.
RunPendingTasks()356 void RunPendingTasks() {
357 base::RunLoop run_loop;
358 run_loop.RunUntilIdle();
359 }
360
361 base::MessageLoop message_loop_;
362 MockCastSocketDelegate mock_delegate_;
363 scoped_ptr<TestCastSocket> socket_;
364 CompleteHandler handler_;
365 MessageInfo test_messages_[arraysize(kTestData)];
366 CastMessage test_protos_[arraysize(kTestData)];
367 std::string test_proto_strs_[arraysize(kTestData)];
368 std::string auth_request_;
369 std::string auth_reply_;
370 };
371
372 // Tests connecting and closing the socket.
TEST_F(CastSocketTest,TestConnectAndClose)373 TEST_F(CastSocketTest, TestConnectAndClose) {
374 CreateCastSocket();
375 ConnectHelper();
376 SetupAuthMessage();
377 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
378 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
379
380 EXPECT_CALL(handler_, OnCloseComplete(net::OK));
381 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
382 base::Unretained(&handler_)));
383 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
384 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
385 }
386
387 // Tests that the following connection flow works:
388 // - TCP connection succeeds (async)
389 // - SSL connection succeeds (async)
TEST_F(CastSocketTest,TestConnect)390 TEST_F(CastSocketTest, TestConnect) {
391 CreateCastSocket();
392 SetupAuthMessage();
393 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
394 socket_->SetupSsl1Connect(net::ASYNC, net::OK);
395 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
396
397 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
398 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
399 base::Unretained(&handler_)));
400 RunPendingTasks();
401
402 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
403 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
404 }
405
406 // Test that the following connection flow works:
407 // - TCP connection succeeds (async)
408 // - SSL connection fails with cert error (async)
409 // - Cert is extracted successfully
410 // - Second TCP connection succeeds (async)
411 // - Second SSL connection succeeds (async)
TEST_F(CastSocketTest,TestConnectTwoStep)412 TEST_F(CastSocketTest, TestConnectTwoStep) {
413 CreateCastSocket();
414 SetupAuthMessage();
415 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
416 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
417 socket_->SetupTcp2Connect(net::ASYNC, net::OK);
418 socket_->SetupSsl2Connect(net::ASYNC, net::OK);
419 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
420
421 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
422 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
423 base::Unretained(&handler_)));
424 RunPendingTasks();
425
426 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
427 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
428 }
429
430 // Test that the following connection flow works:
431 // - TCP connection succeeds (async)
432 // - SSL connection fails with cert error (async)
433 // - Cert is extracted successfully
434 // - Second TCP connection succeeds (async)
435 // - Second SSL connection fails (async)
436 // - The flow should NOT be tried again
TEST_F(CastSocketTest,TestConnectMaxTwoAttempts)437 TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) {
438 CreateCastSocket();
439 SetupAuthMessage();
440 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
441 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
442 socket_->SetupTcp2Connect(net::ASYNC, net::OK);
443 socket_->SetupSsl2Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
444
445 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
446 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
447 base::Unretained(&handler_)));
448 RunPendingTasks();
449
450 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
451 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
452 }
453
454 // Tests that the following connection flow works:
455 // - TCP connection succeeds (async)
456 // - SSL connection fails with cert error (async)
457 // - Cert is extracted successfully
458 // - Second TCP connection succeeds (async)
459 // - Second SSL connection succeeds (async)
460 // - Challenge request is sent (async)
461 // - Challenge response is received (async)
462 // - Credentials are verified successfuly
TEST_F(CastSocketTest,TestConnectFullSecureFlowAsync)463 TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
464 CreateCastSocketSecure();
465 SetupAuthMessage();
466
467 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
468 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
469 socket_->SetupTcp2Connect(net::ASYNC, net::OK);
470 socket_->SetupSsl2Connect(net::ASYNC, net::OK);
471 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
472 socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
473 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
474
475 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
476 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
477 base::Unretained(&handler_)));
478 RunPendingTasks();
479
480 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
481 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
482 }
483
484 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous.
TEST_F(CastSocketTest,TestConnectFullSecureFlowSync)485 TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
486 CreateCastSocketSecure();
487 SetupAuthMessage();
488
489 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
490 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
491 socket_->SetupTcp2Connect(net::SYNCHRONOUS, net::OK);
492 socket_->SetupSsl2Connect(net::SYNCHRONOUS, net::OK);
493 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, auth_request_);
494 socket_->AddReadResultForMessage(net::SYNCHRONOUS, auth_reply_);
495 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
496
497 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
498 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
499 base::Unretained(&handler_)));
500 RunPendingTasks();
501
502 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
503 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
504 }
505
506 // Test that an AuthMessage with a mangled namespace triggers cancelation
507 // of the connection event loop.
TEST_F(CastSocketTest,TestConnectAuthMessageCorrupted)508 TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) {
509 CreateCastSocketSecure();
510 SetupAuthMessage("bogus_namespace");
511
512 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
513 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
514 socket_->SetupTcp2Connect(net::ASYNC, net::OK);
515 socket_->SetupSsl2Connect(net::ASYNC, net::OK);
516 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
517 socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
518 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
519 // Guard against VerifyChallengeResult() being triggered.
520 socket_->DisallowVerifyChallengeResult();
521
522 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
523 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
524 base::Unretained(&handler_)));
525 RunPendingTasks();
526
527 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
528 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
529 }
530
531 // Test connection error - TCP connect fails (async)
TEST_F(CastSocketTest,TestConnectTcpConnectErrorAsync)532 TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
533 CreateCastSocketSecure();
534 SetupAuthMessage();
535
536 socket_->SetupTcp1Connect(net::ASYNC, net::ERR_FAILED);
537
538 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
539 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
540 base::Unretained(&handler_)));
541 RunPendingTasks();
542
543 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
544 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
545 }
546
547 // Test connection error - TCP connect fails (sync)
TEST_F(CastSocketTest,TestConnectTcpConnectErrorSync)548 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
549 CreateCastSocketSecure();
550 SetupAuthMessage();
551
552 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
553
554 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
555 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
556 base::Unretained(&handler_)));
557 RunPendingTasks();
558
559 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
560 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
561 }
562
563 // Test connection error - SSL connect fails (async)
TEST_F(CastSocketTest,TestConnectSslConnectErrorAsync)564 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
565 CreateCastSocketSecure();
566 SetupAuthMessage();
567
568 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
569 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
570
571 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
572 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
573 base::Unretained(&handler_)));
574 RunPendingTasks();
575
576 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
577 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
578 }
579
580 // Test connection error - SSL connect fails (async)
TEST_F(CastSocketTest,TestConnectSslConnectErrorSync)581 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
582 CreateCastSocketSecure();
583 SetupAuthMessage();
584
585 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
586 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_FAILED);
587
588 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
589 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
590 base::Unretained(&handler_)));
591 RunPendingTasks();
592
593 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
594 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
595 }
596
597 // Test connection error - cert extraction error (async)
TEST_F(CastSocketTest,TestConnectCertExtractionErrorAsync)598 TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
599 CreateCastSocket();
600 SetupAuthMessage();
601 socket_->SetupTcp1Connect(net::ASYNC, net::OK);
602 socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
603 // Set cert extraction to fail
604 socket_->SetExtractCertResult(false);
605
606 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
607 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
608 base::Unretained(&handler_)));
609 RunPendingTasks();
610
611 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
612 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
613 }
614
615 // Test connection error - cert extraction error (sync)
TEST_F(CastSocketTest,TestConnectCertExtractionErrorSync)616 TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
617 CreateCastSocket();
618 SetupAuthMessage();
619 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
620 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
621 // Set cert extraction to fail
622 socket_->SetExtractCertResult(false);
623
624 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
625 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
626 base::Unretained(&handler_)));
627 RunPendingTasks();
628
629 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
630 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
631 }
632
633 // Test connection error - challenge send fails
TEST_F(CastSocketTest,TestConnectChallengeSendError)634 TEST_F(CastSocketTest, TestConnectChallengeSendError) {
635 CreateCastSocketSecure();
636 SetupAuthMessage();
637
638 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
639 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
640 socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
641
642 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
643 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
644 base::Unretained(&handler_)));
645 RunPendingTasks();
646
647 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
648 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
649 }
650
651 // Test connection error - challenge reply receive fails
TEST_F(CastSocketTest,TestConnectChallengeReplyReceiveError)652 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
653 CreateCastSocketSecure();
654 SetupAuthMessage();
655
656 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
657 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
658 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
659 socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
660
661 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
662 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
663 base::Unretained(&handler_)));
664 RunPendingTasks();
665
666 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
667 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
668 }
669
670 // Test connection error - challenge reply verification fails
TEST_F(CastSocketTest,TestConnectChallengeVerificationFails)671 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
672 CreateCastSocketSecure();
673 SetupAuthMessage();
674
675 socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
676 socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
677 socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
678 socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
679 socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
680 socket_->SetVerifyChallengeResult(false);
681
682 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
683 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
684 base::Unretained(&handler_)));
685 RunPendingTasks();
686
687 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
688 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
689 }
690
691 // Test write success - single message (async)
TEST_F(CastSocketTest,TestWriteAsync)692 TEST_F(CastSocketTest, TestWriteAsync) {
693 CreateCastSocket();
694 socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0]);
695 ConnectHelper();
696 SetupAuthMessage();
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 - single message (sync)
TEST_F(CastSocketTest,TestWriteSync)709 TEST_F(CastSocketTest, TestWriteSync) {
710 CreateCastSocket();
711 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
712 ConnectHelper();
713 SetupAuthMessage();
714
715 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
716 socket_->SendMessage(test_messages_[0],
717 base::Bind(&CompleteHandler::OnWriteComplete,
718 base::Unretained(&handler_)));
719 RunPendingTasks();
720
721 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
722 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
723 }
724
725 // Test write success - single message sent in multiple chunks (async)
TEST_F(CastSocketTest,TestWriteChunkedAsync)726 TEST_F(CastSocketTest, TestWriteChunkedAsync) {
727 CreateCastSocket();
728 socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
729 ConnectHelper();
730 SetupAuthMessage();
731
732 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
733 socket_->SendMessage(test_messages_[0],
734 base::Bind(&CompleteHandler::OnWriteComplete,
735 base::Unretained(&handler_)));
736 RunPendingTasks();
737
738 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
739 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
740 }
741
742 // Test write success - single message sent in multiple chunks (sync)
TEST_F(CastSocketTest,TestWriteChunkedSync)743 TEST_F(CastSocketTest, TestWriteChunkedSync) {
744 CreateCastSocket();
745 socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
746 ConnectHelper();
747 SetupAuthMessage();
748
749 EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
750 socket_->SendMessage(test_messages_[0],
751 base::Bind(&CompleteHandler::OnWriteComplete,
752 base::Unretained(&handler_)));
753 RunPendingTasks();
754
755 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
756 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
757 }
758
759 // Test write success - multiple messages (async)
TEST_F(CastSocketTest,TestWriteManyAsync)760 TEST_F(CastSocketTest, TestWriteManyAsync) {
761 CreateCastSocket();
762 for (size_t i = 0; i < arraysize(test_messages_); i++) {
763 size_t msg_size = test_proto_strs_[i].size();
764 socket_->AddWriteResult(net::ASYNC, msg_size);
765 EXPECT_CALL(handler_, OnWriteComplete(msg_size));
766 }
767 ConnectHelper();
768 SetupAuthMessage();
769
770 for (size_t i = 0; i < arraysize(test_messages_); i++) {
771 socket_->SendMessage(test_messages_[i],
772 base::Bind(&CompleteHandler::OnWriteComplete,
773 base::Unretained(&handler_)));
774 }
775 RunPendingTasks();
776
777 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
778 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
779 }
780
781 // Test write success - multiple messages (sync)
TEST_F(CastSocketTest,TestWriteManySync)782 TEST_F(CastSocketTest, TestWriteManySync) {
783 CreateCastSocket();
784 for (size_t i = 0; i < arraysize(test_messages_); i++) {
785 size_t msg_size = test_proto_strs_[i].size();
786 socket_->AddWriteResult(net::SYNCHRONOUS, msg_size);
787 EXPECT_CALL(handler_, OnWriteComplete(msg_size));
788 }
789 ConnectHelper();
790 SetupAuthMessage();
791
792 for (size_t i = 0; i < arraysize(test_messages_); i++) {
793 socket_->SendMessage(test_messages_[i],
794 base::Bind(&CompleteHandler::OnWriteComplete,
795 base::Unretained(&handler_)));
796 }
797 RunPendingTasks();
798
799 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
800 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
801 }
802
803 // Test write error - not connected
TEST_F(CastSocketTest,TestWriteErrorNotConnected)804 TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
805 CreateCastSocket();
806 SetupAuthMessage();
807
808 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
809 socket_->SendMessage(test_messages_[0],
810 base::Bind(&CompleteHandler::OnWriteComplete,
811 base::Unretained(&handler_)));
812
813 EXPECT_EQ(cast_channel::READY_STATE_NONE, socket_->ready_state());
814 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
815 }
816
817 // Test write error - very large message
TEST_F(CastSocketTest,TestWriteErrorLargeMessage)818 TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
819 CreateCastSocket();
820 ConnectHelper();
821 SetupAuthMessage();
822
823 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
824 size_t size = CastSocket::MessageHeader::max_message_size() + 1;
825 test_messages_[0].data.reset(
826 new base::StringValue(std::string(size, 'a')));
827 socket_->SendMessage(test_messages_[0],
828 base::Bind(&CompleteHandler::OnWriteComplete,
829 base::Unretained(&handler_)));
830
831 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
832 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
833
834 }
835
836 // Test write error - network error (sync)
TEST_F(CastSocketTest,TestWriteNetworkErrorSync)837 TEST_F(CastSocketTest, TestWriteNetworkErrorSync) {
838 CreateCastSocket();
839 socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
840 ConnectHelper();
841 SetupAuthMessage();
842
843 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
844 EXPECT_CALL(mock_delegate_,
845 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
846 socket_->SendMessage(test_messages_[0],
847 base::Bind(&CompleteHandler::OnWriteComplete,
848 base::Unretained(&handler_)));
849 RunPendingTasks();
850
851 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
852 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
853 }
854
855 // Test write error - network error (async)
TEST_F(CastSocketTest,TestWriteErrorAsync)856 TEST_F(CastSocketTest, TestWriteErrorAsync) {
857 CreateCastSocket();
858 socket_->AddWriteResult(net::ASYNC, net::ERR_FAILED);
859 ConnectHelper();
860 SetupAuthMessage();
861
862 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
863 EXPECT_CALL(mock_delegate_,
864 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
865 socket_->SendMessage(test_messages_[0],
866 base::Bind(&CompleteHandler::OnWriteComplete,
867 base::Unretained(&handler_)));
868 RunPendingTasks();
869
870 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
871 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
872 }
873
874 // Test write error - 0 bytes written should be considered an error
TEST_F(CastSocketTest,TestWriteErrorZeroBytesWritten)875 TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) {
876 CreateCastSocket();
877 socket_->AddWriteResult(net::SYNCHRONOUS, 0);
878 ConnectHelper();
879 SetupAuthMessage();
880
881 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
882 EXPECT_CALL(mock_delegate_,
883 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
884 socket_->SendMessage(test_messages_[0],
885 base::Bind(&CompleteHandler::OnWriteComplete,
886 base::Unretained(&handler_)));
887 RunPendingTasks();
888
889 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
890 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
891 }
892
893 // Test that when an error occurrs in one write, write callback is invoked for
894 // all pending writes with the error
TEST_F(CastSocketTest,TestWriteErrorWithMultiplePendingWritesAsync)895 TEST_F(CastSocketTest, TestWriteErrorWithMultiplePendingWritesAsync) {
896 CreateCastSocket();
897 socket_->AddWriteResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
898 ConnectHelper();
899 SetupAuthMessage();
900
901 const int num_writes = arraysize(test_messages_);
902 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED))
903 .Times(num_writes);
904 EXPECT_CALL(mock_delegate_,
905 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
906 for (int i = 0; i < num_writes; i++) {
907 socket_->SendMessage(test_messages_[i],
908 base::Bind(&CompleteHandler::OnWriteComplete,
909 base::Unretained(&handler_)));
910 }
911 RunPendingTasks();
912
913 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
914 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
915 }
916
917 // Test read success - single message (async)
TEST_F(CastSocketTest,TestReadAsync)918 TEST_F(CastSocketTest, TestReadAsync) {
919 CreateCastSocket();
920 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0]);
921 EXPECT_CALL(mock_delegate_,
922 OnMessage(socket_.get(), A<const MessageInfo&>()));
923 ConnectHelper();
924 SetupAuthMessage();
925
926 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
927 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
928 }
929
930 // Test read success - single message (sync)
TEST_F(CastSocketTest,TestReadSync)931 TEST_F(CastSocketTest, TestReadSync) {
932 CreateCastSocket();
933 SetupAuthMessage();
934 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
935 EXPECT_CALL(mock_delegate_,
936 OnMessage(socket_.get(), A<const MessageInfo&>()));
937 ConnectHelper();
938
939 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
940 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
941 }
942
943 // Test read success - single message received in multiple chunks (async)
TEST_F(CastSocketTest,TestReadChunkedAsync)944 TEST_F(CastSocketTest, TestReadChunkedAsync) {
945 CreateCastSocket();
946 SetupAuthMessage();
947 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
948 EXPECT_CALL(mock_delegate_,
949 OnMessage(socket_.get(), A<const MessageInfo&>()));
950 ConnectHelper();
951
952 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
953 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
954 }
955
956 // Test read success - single message received in multiple chunks (sync)
TEST_F(CastSocketTest,TestReadChunkedSync)957 TEST_F(CastSocketTest, TestReadChunkedSync) {
958 CreateCastSocket();
959 SetupAuthMessage();
960 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
961 EXPECT_CALL(mock_delegate_,
962 OnMessage(socket_.get(), A<const MessageInfo&>()));
963 ConnectHelper();
964
965 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
966 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
967 }
968
969 // Test read success - multiple messages (async)
TEST_F(CastSocketTest,TestReadManyAsync)970 TEST_F(CastSocketTest, TestReadManyAsync) {
971 CreateCastSocket();
972 SetupAuthMessage();
973 size_t num_reads = arraysize(test_proto_strs_);
974 for (size_t i = 0; i < num_reads; i++)
975 socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[i]);
976 EXPECT_CALL(mock_delegate_,
977 OnMessage(socket_.get(), A<const MessageInfo&>()))
978 .Times(num_reads);
979 ConnectHelper();
980
981 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
982 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
983 }
984
985 // Test read success - multiple messages (sync)
TEST_F(CastSocketTest,TestReadManySync)986 TEST_F(CastSocketTest, TestReadManySync) {
987 CreateCastSocket();
988 SetupAuthMessage();
989 size_t num_reads = arraysize(test_proto_strs_);
990 for (size_t i = 0; i < num_reads; i++)
991 socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[i]);
992 EXPECT_CALL(mock_delegate_,
993 OnMessage(socket_.get(), A<const MessageInfo&>()))
994 .Times(num_reads);
995 ConnectHelper();
996
997 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
998 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
999 }
1000
1001 // Test read error - network error (async)
TEST_F(CastSocketTest,TestReadErrorAsync)1002 TEST_F(CastSocketTest, TestReadErrorAsync) {
1003 CreateCastSocket();
1004 SetupAuthMessage();
1005 socket_->AddReadResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
1006 EXPECT_CALL(mock_delegate_,
1007 OnError(socket_.get(),
1008 cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
1009 ConnectHelper();
1010
1011 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
1012 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
1013 }
1014
1015 // Test read error - network error (sync)
TEST_F(CastSocketTest,TestReadErrorSync)1016 TEST_F(CastSocketTest, TestReadErrorSync) {
1017 CreateCastSocket();
1018 SetupAuthMessage();
1019 socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_SOCKET_NOT_CONNECTED);
1020 EXPECT_CALL(mock_delegate_,
1021 OnError(socket_.get(),
1022 cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
1023 ConnectHelper();
1024
1025 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
1026 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
1027 }
1028
1029 // Test read error - header parse error
TEST_F(CastSocketTest,TestReadHeaderParseError)1030 TEST_F(CastSocketTest, TestReadHeaderParseError) {
1031 CreateCastSocket();
1032 SetupAuthMessage();
1033 uint32 body_size = base::HostToNet32(
1034 CastSocket::MessageHeader::max_message_size() + 1);
1035 // TODO(munjal): Add a method to cast_message_util.h to serialize messages
1036 char header[sizeof(body_size)];
1037 memcpy(&header, &body_size, arraysize(header));
1038 socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
1039 EXPECT_CALL(mock_delegate_,
1040 OnError(socket_.get(),
1041 cast_channel::CHANNEL_ERROR_INVALID_MESSAGE));
1042 ConnectHelper();
1043
1044 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
1045 EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
1046 socket_->error_state());
1047 }
1048
1049 // Test read error - body parse error
TEST_F(CastSocketTest,TestReadBodyParseError)1050 TEST_F(CastSocketTest, TestReadBodyParseError) {
1051 CreateCastSocket();
1052 SetupAuthMessage();
1053 char body[] = "some body";
1054 uint32 body_size = base::HostToNet32(arraysize(body));
1055 char header[sizeof(body_size)];
1056 memcpy(&header, &body_size, arraysize(header));
1057 socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
1058 socket_->AddReadResult(net::SYNCHRONOUS, body, arraysize(body));
1059 EXPECT_CALL(mock_delegate_,
1060 OnError(socket_.get(),
1061 cast_channel::CHANNEL_ERROR_INVALID_MESSAGE));
1062 ConnectHelper();
1063
1064 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
1065 EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
1066 socket_->error_state());
1067 }
1068
1069 } // namespace cast_channel
1070 } // namespace api
1071 } // namespace extensions
1072