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

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