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