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