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

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