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 "chrome/browser/extensions/api/cast_channel/cast_channel.pb.h"
   8 #include "chrome/browser/extensions/api/cast_channel/cast_message_util.h"
   9 #include "net/base/address_list.h"
  10 #include "net/base/capturing_net_log.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/base/net_log.h"
  14 #include "net/socket/socket_test_util.h"
  15 #include "net/socket/ssl_client_socket.h"
  16 #include "net/socket/tcp_client_socket.h"
  17 #include "net/ssl/ssl_info.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using ::testing::_;
  22 using ::testing::A;
  23 using ::testing::DoAll;
  24 using ::testing::Return;
  25 using ::testing::SaveArg;
  26
  27 namespace extensions {
  28 namespace api {
  29 namespace cast_channel {
  30
  31 class MockCastSocketDelegate : public CastSocket::Delegate {
  32  public:
  33   MOCK_METHOD2(OnError, void(const CastSocket* socket,
  34                              ChannelError error));
  35   MOCK_METHOD2(OnMessage, void(const CastSocket* socket,
  36                                const MessageInfo& message));
  37 };
  38
  39 class MockTCPClientSocket : public net::TCPClientSocket {
  40  public:
  41   explicit MockTCPClientSocket() :
  42       TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()) { }
  43   virtual ~MockTCPClientSocket() { }
  44
  45   MOCK_METHOD1(Connect, int(const net::CompletionCallback& callback));
  46   MOCK_METHOD2(SetKeepAlive, bool(bool, int));
  47   MOCK_METHOD1(SetNoDelay, bool(bool));
  48   MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
  49                          const net::CompletionCallback& callback));
  50   MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
  51                           const net::CompletionCallback& callback));
  52   MOCK_METHOD0(Disconnect, void());
  53 };
  54
  55 class MockSSLClientSocket : public net::MockClientSocket {
  56  public:
  57   MockSSLClientSocket() : MockClientSocket(net::BoundNetLog()) { }
  58   virtual ~MockSSLClientSocket() { }
  59
  60   MOCK_METHOD1(Connect, int(const net::CompletionCallback& callback));
  61   MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
  62                          const net::CompletionCallback& callback));
  63   MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
  64                           const net::CompletionCallback& callback));
  65   MOCK_METHOD0(Disconnect, void());
  66   MOCK_CONST_METHOD0(WasEverUsed, bool());
  67   MOCK_CONST_METHOD0(UsingTCPFastOpen, bool());
  68   MOCK_CONST_METHOD0(WasNpnNegotiated, bool());
  69   MOCK_METHOD1(GetSSLInfo, bool(net::SSLInfo*));
  70 };
  71
  72 class CompleteHandler {
  73  public:
  74   CompleteHandler() {}
  75   MOCK_METHOD1(OnCloseComplete, void(int result));
  76   MOCK_METHOD1(OnConnectComplete, void(int result));
  77   MOCK_METHOD1(OnWriteComplete, void(int result));
  78  private:
  79   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
  80 };
  81
  82 class TestCastSocket : public CastSocket {
  83  public:
  84   static scoped_ptr<TestCastSocket> Create(
  85       MockCastSocketDelegate* delegate) {
  86     return scoped_ptr<TestCastSocket>(
  87         new TestCastSocket(delegate, "cast://192.0.0.1:8009"));
  88   }
  89
  90   static scoped_ptr<TestCastSocket> CreateSecure(
  91       MockCastSocketDelegate* delegate) {
  92     return scoped_ptr<TestCastSocket>(
  93         new TestCastSocket(delegate, "casts://192.0.0.1:8009"));
  94   }
  95
  96   explicit TestCastSocket(MockCastSocketDelegate* delegate,
  97                           const std::string& url) :
  98     CastSocket("abcdefg", GURL(url), delegate,
  99                &capturing_net_log_),
 100     mock_tcp_socket_(new MockTCPClientSocket()),
 101     mock_ssl_socket_(new MockSSLClientSocket()),
 102     owns_tcp_socket_(true),
 103     owns_ssl_socket_(true),
 104     extract_cert_result_(true),
 105     send_auth_challenge_result_(net::ERR_IO_PENDING),
 106     read_auth_challenge_reply_result_(net::ERR_IO_PENDING),
 107     challenge_reply_result_(true) {
 108   }
 109
 110   virtual ~TestCastSocket() {
 111     if (owns_tcp_socket_) {
 112       DCHECK(mock_tcp_socket_);
 113       delete mock_tcp_socket_;
 114     }
 115     if (owns_ssl_socket_) {
 116       DCHECK(mock_ssl_socket_);
 117       delete mock_ssl_socket_;
 118     }
 119   }
 120
 121   virtual void Close(const net::CompletionCallback& callback) OVERRIDE {
 122     if (!owns_tcp_socket_)
 123       mock_tcp_socket_ = NULL;
 124     if (!owns_ssl_socket_)
 125       mock_ssl_socket_ = NULL;
 126     CastSocket::Close(callback);
 127   }
 128
 129   void CreateNewSockets() {
 130     owns_tcp_socket_ = true;
 131     mock_tcp_socket_ = new MockTCPClientSocket();
 132     owns_ssl_socket_ = true;
 133     mock_ssl_socket_ = new MockSSLClientSocket();
 134   }
 135
 136   void SetExtractCertResult(bool value) {
 137     extract_cert_result_ = value;
 138   }
 139
 140   void SetSendAuthChallengeResult(int result) {
 141     send_auth_challenge_result_ = result;
 142   }
 143
 144   void SetReadAuthChallengeReplyResult(int result) {
 145     read_auth_challenge_reply_result_ = result;
 146   }
 147
 148   void SetChallengeReplyResult(bool value) {
 149     challenge_reply_result_ = value;
 150   }
 151
 152   MockTCPClientSocket* mock_tcp_socket_;
 153   MockSSLClientSocket* mock_ssl_socket_;
 154
 155  protected:
 156   virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE {
 157     owns_tcp_socket_ = false;
 158     return scoped_ptr<net::TCPClientSocket>(mock_tcp_socket_);
 159   }
 160
 161   virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket() OVERRIDE {
 162     owns_ssl_socket_ = false;
 163     return scoped_ptr<net::SSLClientSocket>(mock_ssl_socket_);
 164   }
 165
 166   virtual bool ExtractPeerCert(std::string* cert) OVERRIDE {
 167     if (extract_cert_result_)
 168       cert->assign("dummy_test_cert");
 169     return extract_cert_result_;
 170   }
 171
 172   virtual int SendAuthChallenge() OVERRIDE {
 173     return send_auth_challenge_result_;
 174   }
 175
 176   virtual int ReadAuthChallengeReply() OVERRIDE {
 177     return read_auth_challenge_reply_result_;
 178   }
 179
 180   virtual bool VerifyChallengeReply() OVERRIDE {
 181     return challenge_reply_result_;
 182   }
 183
 184  private:
 185   net::CapturingNetLog capturing_net_log_;
 186   // Whether this object or the parent owns |mock_tcp_socket_|.
 187   bool owns_tcp_socket_;
 188   // Whether this object or the parent owns |mock_ssl_socket_|.
 189   bool owns_ssl_socket_;
 190   // Simulated result of peer cert extraction.
 191   bool extract_cert_result_;
 192   // Simulated result to be returned by SendAuthChallenge.
 193   int send_auth_challenge_result_;
 194   // Simulated result to be returned by ReadAuthChallengeReply.
 195   int read_auth_challenge_reply_result_;
 196   // Simulated result of verifying challenge reply.
 197   bool challenge_reply_result_;
 198 };
 199
 200 class CastSocketTest : public testing::Test {
 201  public:
 202   CastSocketTest() {}
 203   virtual ~CastSocketTest() {}
 204
 205   virtual void SetUp() OVERRIDE {
 206     test_message_.namespace_ = "urn:test";
 207     test_message_.source_id = "1";
 208     test_message_.destination_id = "2";
 209     test_message_.data.reset(new base::StringValue("Hello, World!"));
 210     ASSERT_TRUE(MessageInfoToCastMessage(test_message_, &test_proto_));
 211   }
 212
 213   virtual void TearDown() OVERRIDE {
 214     EXPECT_CALL(handler_, OnCloseComplete(net::OK));
 215     socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
 216                               base::Unretained(&handler_)));
 217   }
 218
 219   void CreateCastSocket() {
 220     socket_ = TestCastSocket::Create(&mock_delegate_);
 221   }
 222
 223   void CreateCastSocketSecure() {
 224     socket_ = TestCastSocket::CreateSecure(&mock_delegate_);
 225   }
 226
 227   // Sets an expectation that TCPClientSocket::Connect is called and
 228   // returns |result| and stores the callback passed to it in |callback|.
 229   void ExpectTcpConnect(net::CompletionCallback* callback, int result) {
 230     EXPECT_CALL(mock_tcp_socket(), Connect(A<const net::CompletionCallback&>()))
 231         .Times(1)
 232         .WillOnce(DoAll(SaveArg<0>(callback), Return(result)));
 233     EXPECT_CALL(mock_tcp_socket(), SetKeepAlive(_, _))
 234         .WillOnce(Return(true));
 235   }
 236
 237   // Same as ExpectTcpConnect but to return net::ERR_IO_PENDING.
 238   void ExpectTcpConnectPending(net::CompletionCallback* callback) {
 239     ExpectTcpConnect(callback, net::ERR_IO_PENDING);
 240   }
 241
 242   // Sets an expectation that SSLClientSocket::Connect is called and
 243   // returns |result| and stores the callback passed to it in |callback|.
 244   void ExpectSslConnect(net::CompletionCallback* callback, int result) {
 245     EXPECT_CALL(mock_ssl_socket(), Connect(A<const net::CompletionCallback&>()))
 246         .Times(1)
 247         .WillOnce(DoAll(SaveArg<0>(callback), Return(result)));
 248   }
 249
 250   // Same as ExpectSslConnect but to return net::ERR_IO_PENDING.
 251   void ExpectSslConnectPending(net::CompletionCallback* callback) {
 252     ExpectSslConnect(callback, net::ERR_IO_PENDING);
 253   }
 254
 255   // Sets an expectation that SSLClientSocket::Read is called |times| number
 256   // of times and returns net::ERR_IO_PENDING.
 257   void ExpectSslRead(int times) {
 258     EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
 259                                         A<int>(),
 260                                         A<const net::CompletionCallback&>()))
 261         .Times(times)
 262         .WillOnce(Return(net::ERR_IO_PENDING));
 263   }
 264
 265   // Sets up CastSocket::Connect to succeed.
 266   // Connecting the socket also starts the read loop; we expect the call to
 267   // Read(), but never fire the read callback.
 268   void ConnectHelper() {
 269     net::CompletionCallback connect_callback1;
 270     net::CompletionCallback connect_callback2;
 271
 272     ExpectTcpConnect(&connect_callback1, net::OK);
 273     ExpectSslConnect(&connect_callback2, net::OK);
 274     EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 275     ExpectSslRead(1);
 276
 277     socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 278                                 base::Unretained(&handler_)));
 279
 280     EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 281     EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 282   }
 283
 284  protected:
 285   MockTCPClientSocket& mock_tcp_socket() {
 286     MockTCPClientSocket* mock_socket = socket_->mock_tcp_socket_;
 287     DCHECK(mock_socket);
 288     return *mock_socket;
 289   }
 290
 291   MockSSLClientSocket& mock_ssl_socket() {
 292     MockSSLClientSocket* mock_socket = socket_->mock_ssl_socket_;
 293     DCHECK(mock_socket);
 294     return *mock_socket;
 295   }
 296
 297   void CallOnChallengeEvent(int result) {
 298     socket_->OnChallengeEvent(result);
 299   }
 300
 301   MockCastSocketDelegate mock_delegate_;
 302   scoped_ptr<TestCastSocket> socket_;
 303   CompleteHandler handler_;
 304   MessageInfo test_message_;
 305   CastMessage test_proto_;
 306 };
 307
 308 // Tests URL parsing and validation.
 309 TEST_F(CastSocketTest, TestCastURLs) {
 310   CreateCastSocket();
 311   EXPECT_TRUE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:8009")));
 312   EXPECT_FALSE(socket_->auth_required());
 313   EXPECT_EQ(socket_->ip_endpoint_.ToString(), "192.0.0.1:8009");
 314
 315   EXPECT_TRUE(socket_->ParseChannelUrl(GURL("casts://192.0.0.1:12345")));
 316   EXPECT_TRUE(socket_->auth_required());
 317   EXPECT_EQ(socket_->ip_endpoint_.ToString(), "192.0.0.1:12345");
 318
 319   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("http://192.0.0.1:12345")));
 320   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:192.0.0.1:12345")));
 321   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:///192.0.0.1:12345")));
 322   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://:12345")));
 323   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://abcd:8009")));
 324   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:abcd")));
 325   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("")));
 326   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("foo")));
 327   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast:")));
 328   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast::")));
 329   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1")));
 330   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://:")));
 331   EXPECT_FALSE(socket_->ParseChannelUrl(GURL("cast://192.0.0.1:")));
 332 }
 333
 334 // Tests connecting and closing the socket.
 335 TEST_F(CastSocketTest, TestConnectAndClose) {
 336   CreateCastSocket();
 337   ConnectHelper();
 338
 339   EXPECT_CALL(handler_, OnCloseComplete(net::OK));
 340   socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
 341                             base::Unretained(&handler_)));
 342   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
 343   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 344 }
 345
 346 // Tests that the following connection flow works:
 347 // - TCP connection succeeds (async)
 348 // - SSL connection succeeds (async)
 349 TEST_F(CastSocketTest, TestConnect) {
 350   CreateCastSocket();
 351
 352   net::CompletionCallback connect_callback1;
 353   net::CompletionCallback connect_callback2;
 354
 355   ExpectTcpConnectPending(&connect_callback1);
 356   ExpectSslConnectPending(&connect_callback2);
 357   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 358   ExpectSslRead(1);
 359
 360   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 361                               base::Unretained(&handler_)));
 362   connect_callback1.Run(net::OK);
 363   connect_callback2.Run(net::OK);
 364
 365   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 366   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 367 }
 368
 369 // Test that the following connection flow works:
 370 // - TCP connection succeeds (async)
 371 // - SSL connection fails with cert error (async)
 372 // - Cert is extracted successfully
 373 // - Second TCP connection succeeds (async)
 374 // - Second SSL connection succeeds (async)
 375 TEST_F(CastSocketTest, TestTwoStepConnect) {
 376   CreateCastSocket();
 377
 378   // Expectations for the initial connect call
 379   net::CompletionCallback tcp_connect_callback1;
 380   net::CompletionCallback ssl_connect_callback1;
 381
 382   ExpectTcpConnectPending(&tcp_connect_callback1);
 383   ExpectSslConnectPending(&ssl_connect_callback1);
 384
 385   // Start connect flow
 386   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 387                               base::Unretained(&handler_)));
 388   tcp_connect_callback1.Run(net::OK);
 389
 390   // Expectations for the second connect call
 391   socket_->CreateNewSockets();
 392   net::CompletionCallback tcp_connect_callback2;
 393   net::CompletionCallback ssl_connect_callback2;
 394   ExpectTcpConnectPending(&tcp_connect_callback2);
 395   ExpectSslConnectPending(&ssl_connect_callback2);
 396   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 397   ExpectSslRead(1);
 398
 399   // Trigger callbacks for the first connect
 400   ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
 401
 402   // Trigger callbacks for the second connect
 403   tcp_connect_callback2.Run(net::OK);
 404   ssl_connect_callback2.Run(net::OK);
 405
 406   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 407   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 408 }
 409
 410 // Test that the following connection flow works:
 411 // - TCP connection succeeds (async)
 412 // - SSL connection fails with cert error (async)
 413 // - Cert is extracted successfully
 414 // - Second TCP connection succeeds (async)
 415 // - Second SSL connection fails (async)
 416 // - The flow should NOT be tried again
 417 TEST_F(CastSocketTest, TestMaxTwoConnectAttempts) {
 418   CreateCastSocket();
 419
 420   net::CompletionCallback tcp_connect_callback1;
 421   net::CompletionCallback ssl_connect_callback1;
 422
 423   // Expectations for the initial connect call
 424   ExpectTcpConnectPending(&tcp_connect_callback1);
 425   ExpectSslConnectPending(&ssl_connect_callback1);
 426
 427   // Start connect flow
 428   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 429                               base::Unretained(&handler_)));
 430   tcp_connect_callback1.Run(net::OK);
 431
 432   socket_->CreateNewSockets();
 433   net::CompletionCallback tcp_connect_callback2;
 434   net::CompletionCallback ssl_connect_callback2;
 435
 436   // Expectations for the second connect call
 437   ExpectTcpConnectPending(&tcp_connect_callback2);
 438   ExpectSslConnectPending(&ssl_connect_callback2);
 439   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
 440
 441   // Trigger callbacks for the first connect
 442   ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
 443
 444   // Trigger callbacks for the second connect
 445   tcp_connect_callback2.Run(net::OK);
 446   ssl_connect_callback2.Run(net::ERR_CERT_AUTHORITY_INVALID);
 447
 448   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
 449   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 450 }
 451
 452 // Test that when cert extraction fails the connection flow stops.
 453 TEST_F(CastSocketTest, TestCertExtractionFailure) {
 454   CreateCastSocket();
 455
 456   net::CompletionCallback connect_callback1;
 457   net::CompletionCallback connect_callback2;
 458
 459   ExpectTcpConnectPending(&connect_callback1);
 460   ExpectSslConnectPending(&connect_callback2);
 461
 462   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 463                               base::Unretained(&handler_)));
 464   connect_callback1.Run(net::OK);
 465
 466   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
 467
 468   // Set cert extraction to fail
 469   socket_->SetExtractCertResult(false);
 470   // Attempt to connect results in ERR_CERT_AUTHORTY_INVALID
 471   connect_callback2.Run(net::ERR_CERT_AUTHORITY_INVALID);
 472
 473   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
 474   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 475 }
 476
 477 // Tests that the following connection flow works:
 478 // - TCP connection succeeds (async)
 479 // - SSL connection fails with cert error (async)
 480 // - Cert is extracted successfully
 481 // - Second TCP connection succeeds (async)
 482 // - Second SSL connection succeeds (async)
 483 // - Challenge request is sent (async)
 484 // - Challenge response is received (async)
 485 // - Credentials are verified successfuly
 486 TEST_F(CastSocketTest, TestFullSecureConnectionFlowAsync) {
 487   CreateCastSocketSecure();
 488
 489   net::CompletionCallback tcp_connect_callback1;
 490   net::CompletionCallback ssl_connect_callback1;
 491
 492   // Expectations for the initial connect call
 493   ExpectTcpConnectPending(&tcp_connect_callback1);
 494   ExpectSslConnectPending(&ssl_connect_callback1);
 495
 496   // Start connect flow
 497   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 498                               base::Unretained(&handler_)));
 499   tcp_connect_callback1.Run(net::OK);
 500
 501   socket_->CreateNewSockets();
 502   net::CompletionCallback tcp_connect_callback2;
 503   net::CompletionCallback ssl_connect_callback2;
 504
 505   // Expectations for the second connect call
 506   ExpectTcpConnectPending(&tcp_connect_callback2);
 507   ExpectSslConnectPending(&ssl_connect_callback2);
 508   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 509
 510   // Trigger callbacks for the first connect
 511   ssl_connect_callback1.Run(net::ERR_CERT_AUTHORITY_INVALID);
 512
 513   // Trigger callbacks for the second connect
 514   tcp_connect_callback2.Run(net::OK);
 515   ssl_connect_callback2.Run(net::OK);
 516
 517   // Trigger callbacks for auth events.
 518   CallOnChallengeEvent(net::OK);  // Sent challenge
 519   CallOnChallengeEvent(net::OK);  // Received reply
 520
 521   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 522   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 523 }
 524
 525 // Same as TestFullSecureConnectionFlowAsync, but operations are  synchronous.
 526 TEST_F(CastSocketTest, TestFullSecureConnectionFlowSync) {
 527   CreateCastSocketSecure();
 528
 529   net::CompletionCallback tcp_connect_callback;
 530   net::CompletionCallback ssl_connect_callback;
 531
 532   // Expectations for the connect calls
 533   ExpectTcpConnect(&tcp_connect_callback, net::OK);
 534   ExpectSslConnect(&ssl_connect_callback, net::OK);
 535   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 536
 537   socket_->SetSendAuthChallengeResult(net::OK);
 538   socket_->SetReadAuthChallengeReplyResult(net::OK);
 539
 540   // Start connect flow
 541   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 542                               base::Unretained(&handler_)));
 543
 544   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 545   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 546 }
 547
 548 // Tests writing a single message where the completion is signaled via
 549 // callback.
 550 TEST_F(CastSocketTest, TestWriteViaCallback) {
 551   CreateCastSocket();
 552   ConnectHelper();
 553
 554   net::CompletionCallback write_callback;
 555
 556   EXPECT_CALL(mock_ssl_socket(),
 557               Write(A<net::IOBuffer*>(),
 558                     39,
 559                     A<const net::CompletionCallback&>()))
 560     .Times(1)
 561     .WillOnce(DoAll(SaveArg<2>(&write_callback),
 562                     Return(net::ERR_IO_PENDING)));
 563   EXPECT_CALL(handler_, OnWriteComplete(39));
 564   socket_->SendMessage(test_message_,
 565                        base::Bind(&CompleteHandler::OnWriteComplete,
 566                                   base::Unretained(&handler_)));
 567   write_callback.Run(39);
 568   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 569   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 570 }
 571
 572 // Tests writing a single message where the Write() returns directly.
 573 TEST_F(CastSocketTest, TestWrite) {
 574   CreateCastSocket();
 575   ConnectHelper();
 576
 577   EXPECT_CALL(mock_ssl_socket(),
 578               Write(A<net::IOBuffer*>(),
 579                     39,
 580                     A<const net::CompletionCallback&>()))
 581     .Times(1)
 582     .WillOnce(Return(39));
 583   EXPECT_CALL(handler_, OnWriteComplete(39));
 584   socket_->SendMessage(test_message_,
 585                       base::Bind(&CompleteHandler::OnWriteComplete,
 586                                  base::Unretained(&handler_)));
 587   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 588   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 589 }
 590
 591 // Tests writing multiple messages.
 592 TEST_F(CastSocketTest, TestWriteMany) {
 593   CreateCastSocket();
 594   ConnectHelper();
 595   std::string messages[4];
 596   messages[0] = "Hello, World!";
 597   messages[1] = "Goodbye, World!";
 598   messages[2] = "Hello, Sky!";
 599   messages[3] = "Goodbye, Volcano!";
 600   int sizes[4] = {39, 41, 37, 43};
 601   MessageInfo message_info[4];
 602   net::CompletionCallback write_callback;
 603
 604   for (int i = 0; i < 4; i++) {
 605     EXPECT_CALL(mock_ssl_socket(),
 606                 Write(A<net::IOBuffer*>(),
 607                       sizes[i],
 608                       A<const net::CompletionCallback&>()))
 609       .WillRepeatedly(DoAll(SaveArg<2>(&write_callback),
 610                             Return(net::ERR_IO_PENDING)));
 611     EXPECT_CALL(handler_, OnWriteComplete(sizes[i]));
 612   }
 613
 614   for (int i = 0; i < 4; i++) {
 615     message_info[i].namespace_ = "urn:test";
 616     message_info[i].source_id = "1";
 617     message_info[i].destination_id = "2";
 618     message_info[i].data.reset(new base::StringValue(messages[i]));
 619     socket_->SendMessage(message_info[i],
 620                          base::Bind(&CompleteHandler::OnWriteComplete,
 621                                     base::Unretained(&handler_)));
 622   }
 623   for (int i = 0; i < 4; i++) {
 624     write_callback.Run(sizes[i]);
 625   }
 626   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 627   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 628 }
 629
 630 // Tests error on writing.
 631 TEST_F(CastSocketTest, TestWriteError) {
 632   CreateCastSocket();
 633   ConnectHelper();
 634   net::CompletionCallback write_callback;
 635
 636   EXPECT_CALL(mock_ssl_socket(),
 637               Write(A<net::IOBuffer*>(),
 638                     39,
 639                     A<const net::CompletionCallback&>()))
 640     .Times(1)
 641     .WillOnce(DoAll(SaveArg<2>(&write_callback),
 642                     Return(net::ERR_SOCKET_NOT_CONNECTED)));
 643   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED));
 644   EXPECT_CALL(mock_delegate_,
 645               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
 646   socket_->SendMessage(test_message_,
 647                        base::Bind(&CompleteHandler::OnWriteComplete,
 648                                   base::Unretained(&handler_)));
 649   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
 650   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 651 }
 652
 653 // Tests reading a single message.
 654 TEST_F(CastSocketTest, TestRead) {
 655   CreateCastSocket();
 656
 657   net::CompletionCallback connect_callback1;
 658   net::CompletionCallback connect_callback2;
 659   net::CompletionCallback read_callback;
 660
 661   std::string message_data;
 662   ASSERT_TRUE(CastSocket::Serialize(test_proto_, &message_data));
 663
 664   ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
 665   ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
 666
 667   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 668   EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
 669                                       A<int>(),
 670                                       A<const net::CompletionCallback&>()))
 671       .Times(3)
 672       .WillRepeatedly(DoAll(SaveArg<2>(&read_callback),
 673                             Return(net::ERR_IO_PENDING)));
 674
 675   // Expect the test message to be read and invoke the delegate.
 676   EXPECT_CALL(mock_delegate_,
 677               OnMessage(socket_.get(), A<const MessageInfo&>()));
 678
 679   // Connect the socket.
 680   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 681                               base::Unretained(&handler_)));
 682   connect_callback1.Run(net::OK);
 683   connect_callback2.Run(net::OK);
 684
 685   // Put the test header and message into the io_buffers and invoke the read
 686   // callbacks.
 687   memcpy(socket_->header_read_buffer_->StartOfBuffer(),
 688          message_data.c_str(), 4);
 689   read_callback.Run(4);
 690   memcpy(socket_->body_read_buffer_->StartOfBuffer(),
 691          message_data.c_str() + 4, 35);
 692   read_callback.Run(35);
 693
 694   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 695   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 696 }
 697
 698 // Tests reading multiple messages.
 699 TEST_F(CastSocketTest, TestReadMany) {
 700   CreateCastSocket();
 701
 702   net::CompletionCallback connect_callback1;
 703   net::CompletionCallback connect_callback2;
 704   net::CompletionCallback read_callback;
 705
 706   std::string messages[4];
 707   messages[0] = "Hello, World!";
 708   messages[1] = "Goodbye, World!";
 709   messages[2] = "Hello, Sky!";
 710   messages[3] = "Goodbye, Volcano!";
 711   int sizes[4] = {35, 37, 33, 39};
 712   std::string message_data[4];
 713
 714   // Set up test data
 715   for (int i = 0; i < 4; i++) {
 716     test_proto_.set_payload_utf8(messages[i]);
 717     ASSERT_TRUE(CastSocket::Serialize(test_proto_, &message_data[i]));
 718   }
 719
 720   ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
 721   ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
 722
 723   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 724   EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
 725                                       A<int>(),
 726                                       A<const net::CompletionCallback&>()))
 727     .Times(9)
 728     .WillRepeatedly(DoAll(SaveArg<2>(&read_callback),
 729                           Return(net::ERR_IO_PENDING)));
 730
 731   // Expect the test messages to be read and invoke the delegate.
 732   EXPECT_CALL(mock_delegate_, OnMessage(socket_.get(),
 733                                         A<const MessageInfo&>()))
 734     .Times(4);
 735
 736   // Connect the socket.
 737   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 738                               base::Unretained(&handler_)));
 739   connect_callback1.Run(net::OK);
 740   connect_callback2.Run(net::OK);
 741
 742   // Put the test headers and messages into the io_buffer and invoke the read
 743   // callbacks.
 744   for (int i = 0; i < 4; i++) {
 745     memcpy(socket_->header_read_buffer_->StartOfBuffer(),
 746            message_data[i].c_str(), 4);
 747     read_callback.Run(4);
 748     memcpy(socket_->body_read_buffer_->StartOfBuffer(),
 749            message_data[i].c_str() + 4, sizes[i]);
 750     read_callback.Run(sizes[i]);
 751   }
 752
 753   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
 754   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 755 }
 756
 757 // Tests error on reading.
 758 TEST_F(CastSocketTest, TestReadError) {
 759   CreateCastSocket();
 760
 761   net::CompletionCallback connect_callback1;
 762   net::CompletionCallback connect_callback2;
 763   net::CompletionCallback read_callback;
 764
 765   ExpectTcpConnect(&connect_callback1, net::ERR_IO_PENDING);
 766   ExpectSslConnect(&connect_callback2, net::ERR_IO_PENDING);
 767
 768   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
 769   EXPECT_CALL(mock_ssl_socket(), Read(A<net::IOBuffer*>(),
 770                                       A<int>(),
 771                                       A<const net::CompletionCallback&>()))
 772     .WillOnce(DoAll(SaveArg<2>(&read_callback),
 773                     Return(net::ERR_IO_PENDING)));
 774   EXPECT_CALL(mock_delegate_,
 775               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
 776
 777   // Connect the socket.
 778   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
 779                               base::Unretained(&handler_)));
 780   connect_callback1.Run(net::OK);
 781   connect_callback2.Run(net::OK);
 782
 783   // Cause an error.
 784   read_callback.Run(net::ERR_SOCKET_NOT_CONNECTED);
 785
 786   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
 787   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 788 }
 789
 790 }  // namespace cast_channel
 791 }  // namespace api
 792 }  // namespace extensions