Home | History | Annotate | Download | only in cast_channel 
      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
   1072