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