src/extensions/browser/api/cast_channel/cast_socket_unittest.cc

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