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.
5 #include "chrome/browser/extensions/api/cast_channel/cast_socket.h"
7 #include "chrome/browser/extensions/api/cast_channel/cast_channel.pb.h"
8 #include "chrome/browser/extensions/api/cast_channel/cast_message_util.h"
9 #include "net/base/address_list.h"
10 #include "net/base/capturing_net_log.h"
11 #include "net/base/io_buffer.h"
12 #include "net/base/net_errors.h"
13 #include "net/base/net_log.h"
14 #include "net/socket/socket_test_util.h"
15 #include "net/socket/ssl_client_socket.h"
16 #include "net/socket/tcp_client_socket.h"
17 #include "net/ssl/ssl_info.h"
18 #include "testing/gmock/include/gmock/gmock.h"
19 #include "testing/gtest/include/gtest/gtest.h"
23 using ::testing::DoAll;
24 using ::testing::Return;
25 using ::testing::SaveArg;
27 namespace extensions {
29 namespace cast_channel {
31 class MockCastSocketDelegate : public CastSocket::Delegate {
33 MOCK_METHOD2(OnError, void(const CastSocket* socket,
35 MOCK_METHOD2(OnMessage, void(const CastSocket* socket,
36 const MessageInfo& message));
39 class MockTCPClientSocket : public net::TCPClientSocket {
41 explicit MockTCPClientSocket() :
42 TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()) { }
43 virtual ~MockTCPClientSocket() { }
45 MOCK_METHOD1(Connect, int(const net::CompletionCallback& callback));
46 MOCK_METHOD2(SetKeepAlive, bool(bool, int));
47 MOCK_METHOD1(SetNoDelay, bool(bool));
48 MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
49 const net::CompletionCallback& callback));
50 MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
51 const net::CompletionCallback& callback));
52 MOCK_METHOD0(Disconnect, void());
55 class MockSSLClientSocket : public net::MockClientSocket {
57 MockSSLClientSocket() : MockClientSocket(net::BoundNetLog()) { }
58 virtual ~MockSSLClientSocket() { }
60 MOCK_METHOD1(Connect, int(const net::CompletionCallback& callback));
61 MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
62 const net::CompletionCallback& callback));
63 MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
64 const net::CompletionCallback& callback));
65 MOCK_METHOD0(Disconnect, void());
66 MOCK_CONST_METHOD0(WasEverUsed, bool());
67 MOCK_CONST_METHOD0(UsingTCPFastOpen, bool());
68 MOCK_CONST_METHOD0(WasNpnNegotiated, bool());
69 MOCK_METHOD1(GetSSLInfo, bool(net::SSLInfo*));
72 class CompleteHandler {
75 MOCK_METHOD1(OnCloseComplete, void(int result));
76 MOCK_METHOD1(OnConnectComplete, void(int result));
77 MOCK_METHOD1(OnWriteComplete, void(int result));
79 DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
82 class TestCastSocket : public CastSocket {
84 static scoped_ptr<TestCastSocket> Create(
85 MockCastSocketDelegate* delegate) {
86 return scoped_ptr<TestCastSocket>(
87 new TestCastSocket(delegate, "cast://192.0.0.1:8009"));
90 static scoped_ptr<TestCastSocket> CreateSecure(
91 MockCastSocketDelegate* delegate) {
92 return scoped_ptr<TestCastSocket>(
93 new TestCastSocket(delegate, "casts://192.0.0.1:8009"));
96 explicit TestCastSocket(MockCastSocketDelegate* delegate,
97 const std::string& url) :
98 CastSocket("abcdefg", GURL(url), delegate,
100 mock_tcp_socket_(new MockTCPClientSocket()),
101 mock_ssl_socket_(new MockSSLClientSocket()),
102 owns_tcp_socket_(true),
103 owns_ssl_socket_(true),
104 extract_cert_result_(true),
105 send_auth_challenge_result_(net::ERR_IO_PENDING),
106 read_auth_challenge_reply_result_(net::ERR_IO_PENDING),
107 challenge_reply_result_(true) {
110 virtual ~TestCastSocket() {
111 if (owns_tcp_socket_) {
112 DCHECK(mock_tcp_socket_);
113 delete mock_tcp_socket_;
115 if (owns_ssl_socket_) {
116 DCHECK(mock_ssl_socket_);
117 delete mock_ssl_socket_;
121 virtual void Close(const net::CompletionCallback& callback) OVERRIDE {
122 if (!owns_tcp_socket_)
123 mock_tcp_socket_ = NULL;
124 if (!owns_ssl_socket_)
125 mock_ssl_socket_ = NULL;
126 CastSocket::Close(callback);
129 void CreateNewSockets() {
130 owns_tcp_socket_ = true;
131 mock_tcp_socket_ = new MockTCPClientSocket();
132 owns_ssl_socket_ = true;
133 mock_ssl_socket_ = new MockSSLClientSocket();
136 void SetExtractCertResult(bool value) {
137 extract_cert_result_ = value;
140 void SetSendAuthChallengeResult(int result) {
141 send_auth_challenge_result_ = result;
144 void SetReadAuthChallengeReplyResult(int result) {
145 read_auth_challenge_reply_result_ = result;
148 void SetChallengeReplyResult(bool value) {
149 challenge_reply_result_ = value;
152 MockTCPClientSocket* mock_tcp_socket_;
153 MockSSLClientSocket* mock_ssl_socket_;
156 virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE {
157 owns_tcp_socket_ = false;
158 return scoped_ptr<net::TCPClientSocket>(mock_tcp_socket_);
161 virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket() OVERRIDE {
162 owns_ssl_socket_ = false;
163 return scoped_ptr<net::SSLClientSocket>(mock_ssl_socket_);
166 virtual bool ExtractPeerCert(std::string* cert) OVERRIDE {
167 if (extract_cert_result_)
168 cert->assign("dummy_test_cert");
169 return extract_cert_result_;
172 virtual int SendAuthChallenge() OVERRIDE {
173 return send_auth_challenge_result_;
176 virtual int ReadAuthChallengeReply() OVERRIDE {
177 return read_auth_challenge_reply_result_;
180 virtual bool VerifyChallengeReply() OVERRIDE {
181 return challenge_reply_result_;
185 net::CapturingNetLog capturing_net_log_;
186 // Whether this object or the parent owns |mock_tcp_socket_|.
187 bool owns_tcp_socket_;
188 // Whether this object or the parent owns |mock_ssl_socket_|.
189 bool owns_ssl_socket_;
190 // Simulated result of peer cert extraction.
191 bool extract_cert_result_;
192 // Simulated result to be returned by SendAuthChallenge.
193 int send_auth_challenge_result_;
194 // Simulated result to be returned by ReadAuthChallengeReply.
195 int read_auth_challenge_reply_result_;
196 // Simulated result of verifying challenge reply.
197 bool challenge_reply_result_;
200 class CastSocketTest : public testing::Test {
203 virtual ~CastSocketTest() {}
205 virtual void SetUp() OVERRIDE {
206 test_message_.namespace_ = "urn:test";
207 test_message_.source_id = "1";
208 test_message_.destination_id = "2";
209 test_message_.data.reset(new base::StringValue("Hello, World!"));
210 ASSERT_TRUE(MessageInfoToCastMessage(test_message_, &test_proto_));
213 virtual void TearDown() OVERRIDE {
214 EXPECT_CALL(handler_, OnCloseComplete(net::OK));
215 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
216 base::Unretained(&handler_)));
219 void CreateCastSocket() {
220 socket_ = TestCastSocket::Create(&mock_delegate_);
223 void CreateCastSocketSecure() {
224 socket_ = TestCastSocket::CreateSecure(&mock_delegate_);
227 // Sets an expectation that TCPClientSocket::Connect is called and
228 // returns |result| and stores the callback passed to it in |callback|.
229 void ExpectTcpConnect(net::CompletionCallback* callback, int result) {
230 EXPECT_CALL(mock_tcp_socket(), Connect(A<const net::CompletionCallback&>()))
232 .WillOnce(DoAll(SaveArg<0>(callback), Return(result)));
233 EXPECT_CALL(mock_tcp_socket(), SetKeepAlive(_, _))
234 .WillOnce(Return(true));
237 // Same as ExpectTcpConnect but to return net::ERR_IO_PENDING.
238 void ExpectTcpConnectPending(net::CompletionCallback* callback) {
239 ExpectTcpConnect(callback, net::ERR_IO_PENDING);
242 // Sets an expectation that SSLClientSocket::Connect is called and
243 // returns |result| and stores the callback passed to it in |callback|.
244 void ExpectSslConnect(net::CompletionCallback* callback, int result) {
245 EXPECT_CALL(mock_ssl_socket(), Connect(A<const net::CompletionCallback&>()))
247 .WillOnce(DoAll(SaveArg<0>(callback), Return(result)));
250 // Same as ExpectSslConnect but to return net::ERR_IO_PENDING.
251 void ExpectSslConnectPending(net::CompletionCallback* callback) {
252 ExpectSslConnect(callback, net::ERR_IO_PENDING);
255 // Sets an expectation that SSLClientSocket::Read is called |times| number
256 // of times and returns net::ERR_IO_PENDING.
257 void ExpectSslRead(int times) {
258 EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
260 A<const net::CompletionCallback&>()))
262 .WillOnce(Return(net::ERR_IO_PENDING));
265 // Sets up CastSocket::Connect to succeed.
266 // Connecting the socket also starts the read loop; we expect the call to
267 // Read(), but never fire the read callback.
268 void ConnectHelper() {
269 net::CompletionCallback connect_callback1;
270 net::CompletionCallback connect_callback2;
272 ExpectTcpConnect(&connect_callback1, net::OK);
273 ExpectSslConnect(&connect_callback2, net::OK);
274 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
277 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
278 base::Unretained(&handler_)));
280 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
281 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
285 MockTCPClientSocket& mock_tcp_socket() {
286 MockTCPClientSocket* mock_socket = socket_->mock_tcp_socket_;
291 MockSSLClientSocket& mock_ssl_socket() {
292 MockSSLClientSocket* mock_socket = socket_->mock_ssl_socket_;
297 void CallOnChallengeEvent(int result) {
298 socket_->OnChallengeEvent(result);
301 MockCastSocketDelegate mock_delegate_;
302 scoped_ptr<TestCastSocket> socket_;
303 CompleteHandler handler_;
304 MessageInfo test_message_;
305 CastMessage test_proto_;
308 // Tests URL parsing and validation.
309 TEST_F(CastSocketTest, TestCastURLs) {
311 EXPECT_TRUE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:8009")));
312 EXPECT_FALSE(socket_->auth_required());
313 EXPECT_EQ(socket_->ip_endpoint_.ToString(), "192.0.0.1:8009");
315 EXPECT_TRUE(socket_->ParseChannelUrl(GURL("casts://192.0.0.1:12345")));
316 EXPECT_TRUE(socket_->auth_required());
317 EXPECT_EQ(socket_->ip_endpoint_.ToString(), "192.0.0.1:12345");
319 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("http://192.0.0.1:12345")));
320 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:192.0.0.1:12345")));
321 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:///192.0.0.1:12345")));
322 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://:12345")));
323 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://abcd:8009")));
324 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:abcd")));
325 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("")));
326 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("foo")));
327 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:")));
328 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast::")));
329 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1")));
330 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://:")));
331 EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:")));
334 // Tests connecting and closing the socket.
335 TEST_F(CastSocketTest, TestConnectAndClose) {
339 EXPECT_CALL(handler_, OnCloseComplete(net::OK));
340 socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
341 base::Unretained(&handler_)));
342 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
343 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
346 // Tests that the following connection flow works:
347 // - TCP connection succeeds (async)
348 // - SSL connection succeeds (async)
349 TEST_F(CastSocketTest, TestConnect) {
352 net::CompletionCallback connect_callback1;
353 net::CompletionCallback connect_callback2;
355 ExpectTcpConnectPending(&connect_callback1);
356 ExpectSslConnectPending(&connect_callback2);
357 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
360 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
361 base::Unretained(&handler_)));
362 connect_callback1.Run(net::OK);
363 connect_callback2.Run(net::OK);
365 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
366 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
369 // Test that the following connection flow works:
370 // - TCP connection succeeds (async)
371 // - SSL connection fails with cert error (async)
372 // - Cert is extracted successfully
373 // - Second TCP connection succeeds (async)
374 // - Second SSL connection succeeds (async)
375 TEST_F(CastSocketTest, TestTwoStepConnect) {
378 // Expectations for the initial connect call
379 net::CompletionCallback tcp_connect_callback1;
380 net::CompletionCallback ssl_connect_callback1;
382 ExpectTcpConnectPending(&tcp_connect_callback1);
383 ExpectSslConnectPending(&ssl_connect_callback1);
385 // Start connect flow
386 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
387 base::Unretained(&handler_)));
388 tcp_connect_callback1.Run(net::OK);
390 // Expectations for the second connect call
391 socket_->CreateNewSockets();
392 net::CompletionCallback tcp_connect_callback2;
393 net::CompletionCallback ssl_connect_callback2;
394 ExpectTcpConnectPending(&tcp_connect_callback2);
395 ExpectSslConnectPending(&ssl_connect_callback2);
396 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
399 // Trigger callbacks for the first connect
400 ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
402 // Trigger callbacks for the second connect
403 tcp_connect_callback2.Run(net::OK);
404 ssl_connect_callback2.Run(net::OK);
406 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
407 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
410 // Test that the following connection flow works:
411 // - TCP connection succeeds (async)
412 // - SSL connection fails with cert error (async)
413 // - Cert is extracted successfully
414 // - Second TCP connection succeeds (async)
415 // - Second SSL connection fails (async)
416 // - The flow should NOT be tried again
417 TEST_F(CastSocketTest, TestMaxTwoConnectAttempts) {
420 net::CompletionCallback tcp_connect_callback1;
421 net::CompletionCallback ssl_connect_callback1;
423 // Expectations for the initial connect call
424 ExpectTcpConnectPending(&tcp_connect_callback1);
425 ExpectSslConnectPending(&ssl_connect_callback1);
427 // Start connect flow
428 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
429 base::Unretained(&handler_)));
430 tcp_connect_callback1.Run(net::OK);
432 socket_->CreateNewSockets();
433 net::CompletionCallback tcp_connect_callback2;
434 net::CompletionCallback ssl_connect_callback2;
436 // Expectations for the second connect call
437 ExpectTcpConnectPending(&tcp_connect_callback2);
438 ExpectSslConnectPending(&ssl_connect_callback2);
439 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
441 // Trigger callbacks for the first connect
442 ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
444 // Trigger callbacks for the second connect
445 tcp_connect_callback2.Run(net::OK);
446 ssl_connect_callback2.Run(net::ERR_CERT_AUTHORITY_INVALID);
448 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
449 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
452 // Test that when cert extraction fails the connection flow stops.
453 TEST_F(CastSocketTest, TestCertExtractionFailure) {
456 net::CompletionCallback connect_callback1;
457 net::CompletionCallback connect_callback2;
459 ExpectTcpConnectPending(&connect_callback1);
460 ExpectSslConnectPending(&connect_callback2);
462 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
463 base::Unretained(&handler_)));
464 connect_callback1.Run(net::OK);
466 EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
468 // Set cert extraction to fail
469 socket_->SetExtractCertResult(false);
470 // Attempt to connect results in ERR_CERT_AUTHORTY_INVALID
471 connect_callback2.Run(net::ERR_CERT_AUTHORITY_INVALID);
473 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
474 EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
477 // Tests that the following connection flow works:
478 // - TCP connection succeeds (async)
479 // - SSL connection fails with cert error (async)
480 // - Cert is extracted successfully
481 // - Second TCP connection succeeds (async)
482 // - Second SSL connection succeeds (async)
483 // - Challenge request is sent (async)
484 // - Challenge response is received (async)
485 // - Credentials are verified successfuly
486 TEST_F(CastSocketTest, TestFullSecureConnectionFlowAsync) {
487 CreateCastSocketSecure();
489 net::CompletionCallback tcp_connect_callback1;
490 net::CompletionCallback ssl_connect_callback1;
492 // Expectations for the initial connect call
493 ExpectTcpConnectPending(&tcp_connect_callback1);
494 ExpectSslConnectPending(&ssl_connect_callback1);
496 // Start connect flow
497 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
498 base::Unretained(&handler_)));
499 tcp_connect_callback1.Run(net::OK);
501 socket_->CreateNewSockets();
502 net::CompletionCallback tcp_connect_callback2;
503 net::CompletionCallback ssl_connect_callback2;
505 // Expectations for the second connect call
506 ExpectTcpConnectPending(&tcp_connect_callback2);
507 ExpectSslConnectPending(&ssl_connect_callback2);
508 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
510 // Trigger callbacks for the first connect
511 ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
513 // Trigger callbacks for the second connect
514 tcp_connect_callback2.Run(net::OK);
515 ssl_connect_callback2.Run(net::OK);
517 // Trigger callbacks for auth events.
518 CallOnChallengeEvent(net::OK); // Sent challenge
519 CallOnChallengeEvent(net::OK); // Received reply
521 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
522 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
525 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous.
526 TEST_F(CastSocketTest, TestFullSecureConnectionFlowSync) {
527 CreateCastSocketSecure();
529 net::CompletionCallback tcp_connect_callback;
530 net::CompletionCallback ssl_connect_callback;
532 // Expectations for the connect calls
533 ExpectTcpConnect(&tcp_connect_callback, net::OK);
534 ExpectSslConnect(&ssl_connect_callback, net::OK);
535 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
537 socket_->SetSendAuthChallengeResult(net::OK);
538 socket_->SetReadAuthChallengeReplyResult(net::OK);
540 // Start connect flow
541 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
542 base::Unretained(&handler_)));
544 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
545 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
548 // Tests writing a single message where the completion is signaled via
550 TEST_F(CastSocketTest, TestWriteViaCallback) {
554 net::CompletionCallback write_callback;
556 EXPECT_CALL(mock_ssl_socket(),
557 Write(A<net::IOBuffer*>(),
559 A<const net::CompletionCallback&>()))
561 .WillOnce(DoAll(SaveArg<2>(&write_callback),
562 Return(net::ERR_IO_PENDING)));
563 EXPECT_CALL(handler_, OnWriteComplete(39));
564 socket_->SendMessage(test_message_,
565 base::Bind(&CompleteHandler::OnWriteComplete,
566 base::Unretained(&handler_)));
567 write_callback.Run(39);
568 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
569 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
572 // Tests writing a single message where the Write() returns directly.
573 TEST_F(CastSocketTest, TestWrite) {
577 EXPECT_CALL(mock_ssl_socket(),
578 Write(A<net::IOBuffer*>(),
580 A<const net::CompletionCallback&>()))
582 .WillOnce(Return(39));
583 EXPECT_CALL(handler_, OnWriteComplete(39));
584 socket_->SendMessage(test_message_,
585 base::Bind(&CompleteHandler::OnWriteComplete,
586 base::Unretained(&handler_)));
587 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
588 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
591 // Tests writing multiple messages.
592 TEST_F(CastSocketTest, TestWriteMany) {
595 std::string messages[4];
596 messages[0] = "Hello, World!";
597 messages[1] = "Goodbye, World!";
598 messages[2] = "Hello, Sky!";
599 messages[3] = "Goodbye, Volcano!";
600 int sizes[4] = {39, 41, 37, 43};
601 MessageInfo message_info[4];
602 net::CompletionCallback write_callback;
604 for (int i = 0; i < 4; i++) {
605 EXPECT_CALL(mock_ssl_socket(),
606 Write(A<net::IOBuffer*>(),
608 A<const net::CompletionCallback&>()))
609 .WillRepeatedly(DoAll(SaveArg<2>(&write_callback),
610 Return(net::ERR_IO_PENDING)));
611 EXPECT_CALL(handler_, OnWriteComplete(sizes[i]));
614 for (int i = 0; i < 4; i++) {
615 message_info[i].namespace_ = "urn:test";
616 message_info[i].source_id = "1";
617 message_info[i].destination_id = "2";
618 message_info[i].data.reset(new base::StringValue(messages[i]));
619 socket_->SendMessage(message_info[i],
620 base::Bind(&CompleteHandler::OnWriteComplete,
621 base::Unretained(&handler_)));
623 for (int i = 0; i < 4; i++) {
624 write_callback.Run(sizes[i]);
626 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
627 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
630 // Tests error on writing.
631 TEST_F(CastSocketTest, TestWriteError) {
634 net::CompletionCallback write_callback;
636 EXPECT_CALL(mock_ssl_socket(),
637 Write(A<net::IOBuffer*>(),
639 A<const net::CompletionCallback&>()))
641 .WillOnce(DoAll(SaveArg<2>(&write_callback),
642 Return(net::ERR_SOCKET_NOT_CONNECTED)));
643 EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED));
644 EXPECT_CALL(mock_delegate_,
645 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
646 socket_->SendMessage(test_message_,
647 base::Bind(&CompleteHandler::OnWriteComplete,
648 base::Unretained(&handler_)));
649 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
650 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
653 // Tests reading a single message.
654 TEST_F(CastSocketTest, TestRead) {
657 net::CompletionCallback connect_callback1;
658 net::CompletionCallback connect_callback2;
659 net::CompletionCallback read_callback;
661 std::string message_data;
662 ASSERT_TRUE(CastSocket::Serialize(test_proto_, &message_data));
664 ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
665 ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
667 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
668 EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
670 A<const net::CompletionCallback&>()))
672 .WillRepeatedly(DoAll(SaveArg<2>(&read_callback),
673 Return(net::ERR_IO_PENDING)));
675 // Expect the test message to be read and invoke the delegate.
676 EXPECT_CALL(mock_delegate_,
677 OnMessage(socket_.get(), A<const MessageInfo&>()));
679 // Connect the socket.
680 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
681 base::Unretained(&handler_)));
682 connect_callback1.Run(net::OK);
683 connect_callback2.Run(net::OK);
685 // Put the test header and message into the io_buffers and invoke the read
687 memcpy(socket_->header_read_buffer_->StartOfBuffer(),
688 message_data.c_str(), 4);
689 read_callback.Run(4);
690 memcpy(socket_->body_read_buffer_->StartOfBuffer(),
691 message_data.c_str() + 4, 35);
692 read_callback.Run(35);
694 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
695 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
698 // Tests reading multiple messages.
699 TEST_F(CastSocketTest, TestReadMany) {
702 net::CompletionCallback connect_callback1;
703 net::CompletionCallback connect_callback2;
704 net::CompletionCallback read_callback;
706 std::string messages[4];
707 messages[0] = "Hello, World!";
708 messages[1] = "Goodbye, World!";
709 messages[2] = "Hello, Sky!";
710 messages[3] = "Goodbye, Volcano!";
711 int sizes[4] = {35, 37, 33, 39};
712 std::string message_data[4];
715 for (int i = 0; i < 4; i++) {
716 test_proto_.set_payload_utf8(messages[i]);
717 ASSERT_TRUE(CastSocket::Serialize(test_proto_, &message_data[i]));
720 ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
721 ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
723 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
724 EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
726 A<const net::CompletionCallback&>()))
728 .WillRepeatedly(DoAll(SaveArg<2>(&read_callback),
729 Return(net::ERR_IO_PENDING)));
731 // Expect the test messages to be read and invoke the delegate.
732 EXPECT_CALL(mock_delegate_, OnMessage(socket_.get(),
733 A<const MessageInfo&>()))
736 // Connect the socket.
737 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
738 base::Unretained(&handler_)));
739 connect_callback1.Run(net::OK);
740 connect_callback2.Run(net::OK);
742 // Put the test headers and messages into the io_buffer and invoke the read
744 for (int i = 0; i < 4; i++) {
745 memcpy(socket_->header_read_buffer_->StartOfBuffer(),
746 message_data[i].c_str(), 4);
747 read_callback.Run(4);
748 memcpy(socket_->body_read_buffer_->StartOfBuffer(),
749 message_data[i].c_str() + 4, sizes[i]);
750 read_callback.Run(sizes[i]);
753 EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
754 EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
757 // Tests error on reading.
758 TEST_F(CastSocketTest, TestReadError) {
761 net::CompletionCallback connect_callback1;
762 net::CompletionCallback connect_callback2;
763 net::CompletionCallback read_callback;
765 ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
766 ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
768 EXPECT_CALL(handler_, OnConnectComplete(net::OK));
769 EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
771 A<const net::CompletionCallback&>()))
772 .WillOnce(DoAll(SaveArg<2>(&read_callback),
773 Return(net::ERR_IO_PENDING)));
774 EXPECT_CALL(mock_delegate_,
775 OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
777 // Connect the socket.
778 socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
779 base::Unretained(&handler_)));
780 connect_callback1.Run(net::OK);
781 connect_callback2.Run(net::OK);
784 read_callback.Run(net::ERR_SOCKET_NOT_CONNECTED);
786 EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
787 EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
790 } // namespace cast_channel
792 } // namespace extensions