jingle/glue/chrome_async_socket_unittest.cc

   1 // Copyright (c) 2012 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 "jingle/glue/chrome_async_socket.h"
   6
   7 #include <deque>
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "jingle/glue/resolving_client_socket_factory.h"
  15 #include "net/base/address_list.h"
  16 #include "net/base/net_errors.h"
  17 #include "net/base/net_util.h"
  18 #include "net/cert/mock_cert_verifier.h"
  19 #include "net/http/transport_security_state.h"
  20 #include "net/socket/socket_test_util.h"
  21 #include "net/socket/ssl_client_socket.h"
  22 #include "net/ssl/ssl_config_service.h"
  23 #include "net/url_request/url_request_context_getter.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "third_party/libjingle/source/talk/base/ipaddress.h"
  26 #include "third_party/libjingle/source/talk/base/sigslot.h"
  27 #include "third_party/libjingle/source/talk/base/socketaddress.h"
  28
  29 namespace jingle_glue {
  30
  31 namespace {
  32
  33 // Data provider that handles reads/writes for ChromeAsyncSocket.
  34 class AsyncSocketDataProvider : public net::SocketDataProvider {
  35  public:
  36   AsyncSocketDataProvider() : has_pending_read_(false) {}
  37
  38   virtual ~AsyncSocketDataProvider() {
  39     EXPECT_TRUE(writes_.empty());
  40     EXPECT_TRUE(reads_.empty());
  41   }
  42
  43   // If there's no read, sets the "has pending read" flag.  Otherwise,
  44   // pops the next read.
  45   virtual net::MockRead GetNextRead() OVERRIDE {
  46     if (reads_.empty()) {
  47       DCHECK(!has_pending_read_);
  48       has_pending_read_ = true;
  49       const net::MockRead pending_read(net::SYNCHRONOUS, net::ERR_IO_PENDING);
  50       return pending_read;
  51     }
  52     net::MockRead mock_read = reads_.front();
  53     reads_.pop_front();
  54     return mock_read;
  55   }
  56
  57   // Simply pops the next write and, if applicable, compares it to
  58   // |data|.
  59   virtual net::MockWriteResult OnWrite(const std::string& data) OVERRIDE {
  60     DCHECK(!writes_.empty());
  61     net::MockWrite mock_write = writes_.front();
  62     writes_.pop_front();
  63     if (mock_write.result != net::OK) {
  64       return net::MockWriteResult(mock_write.mode, mock_write.result);
  65     }
  66     std::string expected_data(mock_write.data, mock_write.data_len);
  67     EXPECT_EQ(expected_data, data);
  68     if (expected_data != data) {
  69       return net::MockWriteResult(net::SYNCHRONOUS, net::ERR_UNEXPECTED);
  70     }
  71     return net::MockWriteResult(mock_write.mode, data.size());
  72   }
  73
  74   // We ignore resets so we can pre-load the socket data provider with
  75   // read/write events.
  76   virtual void Reset() OVERRIDE {}
  77
  78   // If there is a pending read, completes it with the given read.
  79   // Otherwise, queues up the given read.
  80   void AddRead(const net::MockRead& mock_read) {
  81     DCHECK_NE(mock_read.result, net::ERR_IO_PENDING);
  82     if (has_pending_read_) {
  83       socket()->OnReadComplete(mock_read);
  84       has_pending_read_ = false;
  85       return;
  86     }
  87     reads_.push_back(mock_read);
  88   }
  89
  90   // Simply queues up the given write.
  91   void AddWrite(const net::MockWrite& mock_write) {
  92     writes_.push_back(mock_write);
  93   }
  94
  95  private:
  96   std::deque<net::MockRead> reads_;
  97   bool has_pending_read_;
  98
  99   std::deque<net::MockWrite> writes_;
 100
 101   DISALLOW_COPY_AND_ASSIGN(AsyncSocketDataProvider);
 102 };
 103
 104 class MockXmppClientSocketFactory : public ResolvingClientSocketFactory {
 105  public:
 106   MockXmppClientSocketFactory(
 107       net::ClientSocketFactory* mock_client_socket_factory,
 108       const net::AddressList& address_list)
 109           : mock_client_socket_factory_(mock_client_socket_factory),
 110             address_list_(address_list),
 111             cert_verifier_(new net::MockCertVerifier),
 112             transport_security_state_(new net::TransportSecurityState) {
 113   }
 114
 115   // ResolvingClientSocketFactory implementation.
 116   virtual scoped_ptr<net::StreamSocket> CreateTransportClientSocket(
 117       const net::HostPortPair& host_and_port) OVERRIDE {
 118     return mock_client_socket_factory_->CreateTransportClientSocket(
 119         address_list_, NULL, net::NetLog::Source());
 120   }
 121
 122   virtual scoped_ptr<net::SSLClientSocket> CreateSSLClientSocket(
 123       scoped_ptr<net::ClientSocketHandle> transport_socket,
 124       const net::HostPortPair& host_and_port) OVERRIDE {
 125     net::SSLClientSocketContext context;
 126     context.cert_verifier = cert_verifier_.get();
 127     context.transport_security_state = transport_security_state_.get();
 128     return mock_client_socket_factory_->CreateSSLClientSocket(
 129         transport_socket.Pass(), host_and_port, ssl_config_, context);
 130   }
 131
 132  private:
 133   scoped_ptr<net::ClientSocketFactory> mock_client_socket_factory_;
 134   net::AddressList address_list_;
 135   net::SSLConfig ssl_config_;
 136   scoped_ptr<net::CertVerifier> cert_verifier_;
 137   scoped_ptr<net::TransportSecurityState> transport_security_state_;
 138 };
 139
 140 class ChromeAsyncSocketTest
 141     : public testing::Test,
 142       public sigslot::has_slots<> {
 143  protected:
 144   ChromeAsyncSocketTest()
 145       : ssl_socket_data_provider_(net::ASYNC, net::OK),
 146         addr_("localhost", 35) {}
 147
 148   virtual ~ChromeAsyncSocketTest() {}
 149
 150   virtual void SetUp() {
 151     scoped_ptr<net::MockClientSocketFactory> mock_client_socket_factory(
 152         new net::MockClientSocketFactory());
 153     mock_client_socket_factory->AddSocketDataProvider(
 154         &async_socket_data_provider_);
 155     mock_client_socket_factory->AddSSLSocketDataProvider(
 156         &ssl_socket_data_provider_);
 157
 158     // Fake DNS resolution for |addr_| and pass it to the factory.
 159     net::IPAddressNumber resolved_addr;
 160     EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &resolved_addr));
 161     const net::AddressList address_list =
 162         net::AddressList::CreateFromIPAddress(resolved_addr, addr_.port());
 163     scoped_ptr<MockXmppClientSocketFactory> mock_xmpp_client_socket_factory(
 164         new MockXmppClientSocketFactory(
 165             mock_client_socket_factory.release(),
 166             address_list));
 167     chrome_async_socket_.reset(
 168         new ChromeAsyncSocket(mock_xmpp_client_socket_factory.release(),
 169                               14, 20)),
 170
 171     chrome_async_socket_->SignalConnected.connect(
 172         this, &ChromeAsyncSocketTest::OnConnect);
 173     chrome_async_socket_->SignalSSLConnected.connect(
 174         this, &ChromeAsyncSocketTest::OnSSLConnect);
 175     chrome_async_socket_->SignalClosed.connect(
 176         this, &ChromeAsyncSocketTest::OnClose);
 177     chrome_async_socket_->SignalRead.connect(
 178         this, &ChromeAsyncSocketTest::OnRead);
 179     chrome_async_socket_->SignalError.connect(
 180         this, &ChromeAsyncSocketTest::OnError);
 181   }
 182
 183   virtual void TearDown() {
 184     // Run any tasks that we forgot to pump.
 185     message_loop_.RunUntilIdle();
 186     ExpectClosed();
 187     ExpectNoSignal();
 188     chrome_async_socket_.reset();
 189   }
 190
 191   enum Signal {
 192     SIGNAL_CONNECT,
 193     SIGNAL_SSL_CONNECT,
 194     SIGNAL_CLOSE,
 195     SIGNAL_READ,
 196     SIGNAL_ERROR,
 197   };
 198
 199   // Helper struct that records the state at the time of a signal.
 200
 201   struct SignalSocketState {
 202     SignalSocketState()
 203         : signal(SIGNAL_ERROR),
 204           state(ChromeAsyncSocket::STATE_CLOSED),
 205           error(ChromeAsyncSocket::ERROR_NONE),
 206           net_error(net::OK) {}
 207
 208     SignalSocketState(
 209         Signal signal,
 210         ChromeAsyncSocket::State state,
 211         ChromeAsyncSocket::Error error,
 212         net::Error net_error)
 213         : signal(signal),
 214           state(state),
 215           error(error),
 216           net_error(net_error) {}
 217
 218     bool IsEqual(const SignalSocketState& other) const {
 219       return
 220           (signal == other.signal) &&
 221           (state == other.state) &&
 222           (error == other.error) &&
 223           (net_error == other.net_error);
 224     }
 225
 226     static SignalSocketState FromAsyncSocket(
 227         Signal signal,
 228         buzz::AsyncSocket* async_socket) {
 229       return SignalSocketState(signal,
 230                                async_socket->state(),
 231                                async_socket->error(),
 232                                static_cast<net::Error>(
 233                                    async_socket->GetError()));
 234     }
 235
 236     static SignalSocketState NoError(
 237         Signal signal, buzz::AsyncSocket::State state) {
 238         return SignalSocketState(signal, state,
 239                                  buzz::AsyncSocket::ERROR_NONE,
 240                                  net::OK);
 241     }
 242
 243     Signal signal;
 244     ChromeAsyncSocket::State state;
 245     ChromeAsyncSocket::Error error;
 246     net::Error net_error;
 247   };
 248
 249   void CaptureSocketState(Signal signal) {
 250     signal_socket_states_.push_back(
 251         SignalSocketState::FromAsyncSocket(
 252             signal, chrome_async_socket_.get()));
 253   }
 254
 255   void OnConnect() {
 256     CaptureSocketState(SIGNAL_CONNECT);
 257   }
 258
 259   void OnSSLConnect() {
 260     CaptureSocketState(SIGNAL_SSL_CONNECT);
 261   }
 262
 263   void OnClose() {
 264     CaptureSocketState(SIGNAL_CLOSE);
 265   }
 266
 267   void OnRead() {
 268     CaptureSocketState(SIGNAL_READ);
 269   }
 270
 271   void OnError() {
 272     ADD_FAILURE();
 273   }
 274
 275   // State expect functions.
 276
 277   void ExpectState(ChromeAsyncSocket::State state,
 278                    ChromeAsyncSocket::Error error,
 279                    net::Error net_error) {
 280     EXPECT_EQ(state, chrome_async_socket_->state());
 281     EXPECT_EQ(error, chrome_async_socket_->error());
 282     EXPECT_EQ(net_error, chrome_async_socket_->GetError());
 283   }
 284
 285   void ExpectNonErrorState(ChromeAsyncSocket::State state) {
 286     ExpectState(state, ChromeAsyncSocket::ERROR_NONE, net::OK);
 287   }
 288
 289   void ExpectErrorState(ChromeAsyncSocket::State state,
 290                         ChromeAsyncSocket::Error error) {
 291     ExpectState(state, error, net::OK);
 292   }
 293
 294   void ExpectClosed() {
 295     ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
 296   }
 297
 298   // Signal expect functions.
 299
 300   void ExpectNoSignal() {
 301     if (!signal_socket_states_.empty()) {
 302       ADD_FAILURE() << signal_socket_states_.front().signal;
 303     }
 304   }
 305
 306   void ExpectSignalSocketState(
 307       SignalSocketState expected_signal_socket_state) {
 308     if (signal_socket_states_.empty()) {
 309       ADD_FAILURE() << expected_signal_socket_state.signal;
 310       return;
 311     }
 312     EXPECT_TRUE(expected_signal_socket_state.IsEqual(
 313         signal_socket_states_.front()))
 314         << signal_socket_states_.front().signal;
 315     signal_socket_states_.pop_front();
 316   }
 317
 318   void ExpectReadSignal() {
 319     ExpectSignalSocketState(
 320         SignalSocketState::NoError(
 321             SIGNAL_READ, ChromeAsyncSocket::STATE_OPEN));
 322   }
 323
 324   void ExpectSSLConnectSignal() {
 325     ExpectSignalSocketState(
 326         SignalSocketState::NoError(SIGNAL_SSL_CONNECT,
 327                                    ChromeAsyncSocket::STATE_TLS_OPEN));
 328   }
 329
 330   void ExpectSSLReadSignal() {
 331     ExpectSignalSocketState(
 332         SignalSocketState::NoError(
 333             SIGNAL_READ, ChromeAsyncSocket::STATE_TLS_OPEN));
 334   }
 335
 336   // Open/close utility functions.
 337
 338   void DoOpenClosed() {
 339     ExpectClosed();
 340     async_socket_data_provider_.set_connect_data(
 341         net::MockConnect(net::SYNCHRONOUS, net::OK));
 342     EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 343     ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
 344
 345     message_loop_.RunUntilIdle();
 346     // We may not necessarily be open; may have been other events
 347     // queued up.
 348     ExpectSignalSocketState(
 349         SignalSocketState::NoError(
 350             SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
 351   }
 352
 353   void DoCloseOpened(SignalSocketState expected_signal_socket_state) {
 354     // We may be in an error state, so just compare state().
 355     EXPECT_EQ(ChromeAsyncSocket::STATE_OPEN, chrome_async_socket_->state());
 356     EXPECT_TRUE(chrome_async_socket_->Close());
 357     ExpectSignalSocketState(expected_signal_socket_state);
 358     ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
 359   }
 360
 361   void DoCloseOpenedNoError() {
 362     DoCloseOpened(
 363         SignalSocketState::NoError(
 364             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 365   }
 366
 367   void DoSSLOpenClosed() {
 368     const char kDummyData[] = "dummy_data";
 369     async_socket_data_provider_.AddRead(net::MockRead(kDummyData));
 370     DoOpenClosed();
 371     ExpectReadSignal();
 372     EXPECT_EQ(kDummyData, DrainRead(1));
 373
 374     EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 375     message_loop_.RunUntilIdle();
 376     ExpectSSLConnectSignal();
 377     ExpectNoSignal();
 378     ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 379   }
 380
 381   void DoSSLCloseOpened(SignalSocketState expected_signal_socket_state) {
 382     // We may be in an error state, so just compare state().
 383     EXPECT_EQ(ChromeAsyncSocket::STATE_TLS_OPEN,
 384               chrome_async_socket_->state());
 385     EXPECT_TRUE(chrome_async_socket_->Close());
 386     ExpectSignalSocketState(expected_signal_socket_state);
 387     ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
 388   }
 389
 390   void DoSSLCloseOpenedNoError() {
 391     DoSSLCloseOpened(
 392         SignalSocketState::NoError(
 393             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 394   }
 395
 396   // Read utility fucntions.
 397
 398   std::string DrainRead(size_t buf_size) {
 399     std::string read;
 400     scoped_ptr<char[]> buf(new char[buf_size]);
 401     size_t len_read;
 402     while (true) {
 403       bool success =
 404           chrome_async_socket_->Read(buf.get(), buf_size, &len_read);
 405       if (!success) {
 406         ADD_FAILURE();
 407         break;
 408       }
 409       if (len_read == 0U) {
 410         break;
 411       }
 412       read.append(buf.get(), len_read);
 413     }
 414     return read;
 415   }
 416
 417   // ChromeAsyncSocket expects a message loop.
 418   base::MessageLoop message_loop_;
 419
 420   AsyncSocketDataProvider async_socket_data_provider_;
 421   net::SSLSocketDataProvider ssl_socket_data_provider_;
 422
 423   scoped_ptr<ChromeAsyncSocket> chrome_async_socket_;
 424   std::deque<SignalSocketState> signal_socket_states_;
 425   const talk_base::SocketAddress addr_;
 426
 427  private:
 428   DISALLOW_COPY_AND_ASSIGN(ChromeAsyncSocketTest);
 429 };
 430
 431 TEST_F(ChromeAsyncSocketTest, InitialState) {
 432   ExpectClosed();
 433   ExpectNoSignal();
 434 }
 435
 436 TEST_F(ChromeAsyncSocketTest, EmptyClose) {
 437   ExpectClosed();
 438   EXPECT_TRUE(chrome_async_socket_->Close());
 439   ExpectClosed();
 440 }
 441
 442 TEST_F(ChromeAsyncSocketTest, ImmediateConnectAndClose) {
 443   DoOpenClosed();
 444
 445   ExpectNonErrorState(ChromeAsyncSocket::STATE_OPEN);
 446
 447   DoCloseOpenedNoError();
 448 }
 449
 450 // After this, no need to test immediate successful connect and
 451 // Close() so thoroughly.
 452
 453 TEST_F(ChromeAsyncSocketTest, DoubleClose) {
 454   DoOpenClosed();
 455
 456   EXPECT_TRUE(chrome_async_socket_->Close());
 457   ExpectClosed();
 458   ExpectSignalSocketState(
 459       SignalSocketState::NoError(
 460           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 461
 462   EXPECT_TRUE(chrome_async_socket_->Close());
 463   ExpectClosed();
 464 }
 465
 466 TEST_F(ChromeAsyncSocketTest, NoHostnameConnect) {
 467   talk_base::IPAddress ip_address;
 468   EXPECT_TRUE(talk_base::IPFromString("127.0.0.1", &ip_address));
 469   const talk_base::SocketAddress no_hostname_addr(ip_address, addr_.port());
 470   EXPECT_FALSE(chrome_async_socket_->Connect(no_hostname_addr));
 471   ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
 472                    ChromeAsyncSocket::ERROR_DNS);
 473
 474   EXPECT_TRUE(chrome_async_socket_->Close());
 475   ExpectClosed();
 476 }
 477
 478 TEST_F(ChromeAsyncSocketTest, ZeroPortConnect) {
 479   const talk_base::SocketAddress zero_port_addr(addr_.hostname(), 0);
 480   EXPECT_FALSE(chrome_async_socket_->Connect(zero_port_addr));
 481   ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
 482                    ChromeAsyncSocket::ERROR_DNS);
 483
 484   EXPECT_TRUE(chrome_async_socket_->Close());
 485   ExpectClosed();
 486 }
 487
 488 TEST_F(ChromeAsyncSocketTest, DoubleConnect) {
 489   EXPECT_DEBUG_DEATH({
 490     DoOpenClosed();
 491
 492     EXPECT_FALSE(chrome_async_socket_->Connect(addr_));
 493     ExpectErrorState(ChromeAsyncSocket::STATE_OPEN,
 494                      ChromeAsyncSocket::ERROR_WRONGSTATE);
 495
 496     DoCloseOpened(
 497         SignalSocketState(SIGNAL_CLOSE,
 498                           ChromeAsyncSocket::STATE_CLOSED,
 499                           ChromeAsyncSocket::ERROR_WRONGSTATE,
 500                           net::OK));
 501   }, "non-closed socket");
 502 }
 503
 504 TEST_F(ChromeAsyncSocketTest, ImmediateConnectCloseBeforeRead) {
 505   DoOpenClosed();
 506
 507   EXPECT_TRUE(chrome_async_socket_->Close());
 508   ExpectClosed();
 509   ExpectSignalSocketState(
 510       SignalSocketState::NoError(
 511           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 512
 513   message_loop_.RunUntilIdle();
 514 }
 515
 516 TEST_F(ChromeAsyncSocketTest, HangingConnect) {
 517   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 518   ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
 519   ExpectNoSignal();
 520
 521   EXPECT_TRUE(chrome_async_socket_->Close());
 522   ExpectClosed();
 523   ExpectSignalSocketState(
 524       SignalSocketState::NoError(
 525           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 526 }
 527
 528 TEST_F(ChromeAsyncSocketTest, PendingConnect) {
 529   async_socket_data_provider_.set_connect_data(
 530       net::MockConnect(net::ASYNC, net::OK));
 531   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 532   ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
 533   ExpectNoSignal();
 534
 535   message_loop_.RunUntilIdle();
 536   ExpectNonErrorState(ChromeAsyncSocket::STATE_OPEN);
 537   ExpectSignalSocketState(
 538       SignalSocketState::NoError(
 539           SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
 540   ExpectNoSignal();
 541
 542   message_loop_.RunUntilIdle();
 543
 544   DoCloseOpenedNoError();
 545 }
 546
 547 // After this no need to test successful pending connect so
 548 // thoroughly.
 549
 550 TEST_F(ChromeAsyncSocketTest, PendingConnectCloseBeforeRead) {
 551   async_socket_data_provider_.set_connect_data(
 552       net::MockConnect(net::ASYNC, net::OK));
 553   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 554
 555   message_loop_.RunUntilIdle();
 556   ExpectSignalSocketState(
 557       SignalSocketState::NoError(
 558           SIGNAL_CONNECT, ChromeAsyncSocket::STATE_OPEN));
 559
 560   DoCloseOpenedNoError();
 561
 562   message_loop_.RunUntilIdle();
 563 }
 564
 565 TEST_F(ChromeAsyncSocketTest, PendingConnectError) {
 566   async_socket_data_provider_.set_connect_data(
 567       net::MockConnect(net::ASYNC, net::ERR_TIMED_OUT));
 568   EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 569
 570   message_loop_.RunUntilIdle();
 571
 572   ExpectSignalSocketState(
 573       SignalSocketState(
 574           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 575           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 576 }
 577
 578 // After this we can assume Connect() and Close() work as expected.
 579
 580 TEST_F(ChromeAsyncSocketTest, EmptyRead) {
 581   DoOpenClosed();
 582
 583   char buf[4096];
 584   size_t len_read = 10000U;
 585   EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
 586   EXPECT_EQ(0U, len_read);
 587
 588   DoCloseOpenedNoError();
 589 }
 590
 591 TEST_F(ChromeAsyncSocketTest, WrongRead) {
 592   EXPECT_DEBUG_DEATH({
 593     async_socket_data_provider_.set_connect_data(
 594         net::MockConnect(net::ASYNC, net::OK));
 595     EXPECT_TRUE(chrome_async_socket_->Connect(addr_));
 596     ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
 597     ExpectNoSignal();
 598
 599     char buf[4096];
 600     size_t len_read;
 601     EXPECT_FALSE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
 602     ExpectErrorState(ChromeAsyncSocket::STATE_CONNECTING,
 603                      ChromeAsyncSocket::ERROR_WRONGSTATE);
 604     EXPECT_TRUE(chrome_async_socket_->Close());
 605     ExpectSignalSocketState(
 606         SignalSocketState(
 607             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 608             ChromeAsyncSocket::ERROR_WRONGSTATE, net::OK));
 609   }, "non-open");
 610 }
 611
 612 TEST_F(ChromeAsyncSocketTest, WrongReadClosed) {
 613   char buf[4096];
 614   size_t len_read;
 615   EXPECT_FALSE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
 616   ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
 617                    ChromeAsyncSocket::ERROR_WRONGSTATE);
 618   EXPECT_TRUE(chrome_async_socket_->Close());
 619 }
 620
 621 const char kReadData[] = "mydatatoread";
 622
 623 TEST_F(ChromeAsyncSocketTest, Read) {
 624   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 625   DoOpenClosed();
 626
 627   ExpectReadSignal();
 628   ExpectNoSignal();
 629
 630   EXPECT_EQ(kReadData, DrainRead(1));
 631
 632   message_loop_.RunUntilIdle();
 633
 634   DoCloseOpenedNoError();
 635 }
 636
 637 TEST_F(ChromeAsyncSocketTest, ReadTwice) {
 638   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 639   DoOpenClosed();
 640
 641   ExpectReadSignal();
 642   ExpectNoSignal();
 643
 644   EXPECT_EQ(kReadData, DrainRead(1));
 645
 646   message_loop_.RunUntilIdle();
 647
 648   const char kReadData2[] = "mydatatoread2";
 649   async_socket_data_provider_.AddRead(net::MockRead(kReadData2));
 650
 651   ExpectReadSignal();
 652   ExpectNoSignal();
 653
 654   EXPECT_EQ(kReadData2, DrainRead(1));
 655
 656   DoCloseOpenedNoError();
 657 }
 658
 659 TEST_F(ChromeAsyncSocketTest, ReadError) {
 660   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 661   DoOpenClosed();
 662
 663   ExpectReadSignal();
 664   ExpectNoSignal();
 665
 666   EXPECT_EQ(kReadData, DrainRead(1));
 667
 668   message_loop_.RunUntilIdle();
 669
 670   async_socket_data_provider_.AddRead(
 671       net::MockRead(net::SYNCHRONOUS, net::ERR_TIMED_OUT));
 672
 673   ExpectSignalSocketState(
 674       SignalSocketState(
 675           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 676           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 677 }
 678
 679 TEST_F(ChromeAsyncSocketTest, ReadEmpty) {
 680   async_socket_data_provider_.AddRead(net::MockRead(""));
 681   DoOpenClosed();
 682
 683   ExpectSignalSocketState(
 684       SignalSocketState::NoError(
 685           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 686 }
 687
 688 TEST_F(ChromeAsyncSocketTest, PendingRead) {
 689   DoOpenClosed();
 690
 691   ExpectNoSignal();
 692
 693   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 694
 695   ExpectSignalSocketState(
 696       SignalSocketState::NoError(
 697           SIGNAL_READ, ChromeAsyncSocket::STATE_OPEN));
 698   ExpectNoSignal();
 699
 700   EXPECT_EQ(kReadData, DrainRead(1));
 701
 702   message_loop_.RunUntilIdle();
 703
 704   DoCloseOpenedNoError();
 705 }
 706
 707 TEST_F(ChromeAsyncSocketTest, PendingEmptyRead) {
 708   DoOpenClosed();
 709
 710   ExpectNoSignal();
 711
 712   async_socket_data_provider_.AddRead(net::MockRead(""));
 713
 714   ExpectSignalSocketState(
 715       SignalSocketState::NoError(
 716           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 717 }
 718
 719 TEST_F(ChromeAsyncSocketTest, PendingReadError) {
 720   DoOpenClosed();
 721
 722   ExpectNoSignal();
 723
 724   async_socket_data_provider_.AddRead(
 725       net::MockRead(net::ASYNC, net::ERR_TIMED_OUT));
 726
 727   ExpectSignalSocketState(
 728       SignalSocketState(
 729           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 730           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 731 }
 732
 733 // After this we can assume non-SSL Read() works as expected.
 734
 735 TEST_F(ChromeAsyncSocketTest, WrongWrite) {
 736   EXPECT_DEBUG_DEATH({
 737     std::string data("foo");
 738     EXPECT_FALSE(chrome_async_socket_->Write(data.data(), data.size()));
 739     ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
 740                      ChromeAsyncSocket::ERROR_WRONGSTATE);
 741     EXPECT_TRUE(chrome_async_socket_->Close());
 742   }, "non-open");
 743 }
 744
 745 const char kWriteData[] = "mydatatowrite";
 746
 747 TEST_F(ChromeAsyncSocketTest, SyncWrite) {
 748   async_socket_data_provider_.AddWrite(
 749       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
 750   async_socket_data_provider_.AddWrite(
 751       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
 752   async_socket_data_provider_.AddWrite(
 753       net::MockWrite(net::SYNCHRONOUS,
 754                      kWriteData + 8, arraysize(kWriteData) - 8));
 755   DoOpenClosed();
 756
 757   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 758   message_loop_.RunUntilIdle();
 759   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
 760   message_loop_.RunUntilIdle();
 761   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
 762                                           arraysize(kWriteData) - 8));
 763   message_loop_.RunUntilIdle();
 764
 765   ExpectNoSignal();
 766
 767   DoCloseOpenedNoError();
 768 }
 769
 770 TEST_F(ChromeAsyncSocketTest, AsyncWrite) {
 771   DoOpenClosed();
 772
 773   async_socket_data_provider_.AddWrite(
 774       net::MockWrite(net::ASYNC, kWriteData, 3));
 775   async_socket_data_provider_.AddWrite(
 776       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
 777   async_socket_data_provider_.AddWrite(
 778       net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
 779
 780   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 781   message_loop_.RunUntilIdle();
 782   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
 783   message_loop_.RunUntilIdle();
 784   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
 785                                           arraysize(kWriteData) - 8));
 786   message_loop_.RunUntilIdle();
 787
 788   ExpectNoSignal();
 789
 790   DoCloseOpenedNoError();
 791 }
 792
 793 TEST_F(ChromeAsyncSocketTest, AsyncWriteError) {
 794   DoOpenClosed();
 795
 796   async_socket_data_provider_.AddWrite(
 797       net::MockWrite(net::ASYNC, kWriteData, 3));
 798   async_socket_data_provider_.AddWrite(
 799       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
 800   async_socket_data_provider_.AddWrite(
 801       net::MockWrite(net::ASYNC, net::ERR_TIMED_OUT));
 802
 803   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 804   message_loop_.RunUntilIdle();
 805   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
 806   message_loop_.RunUntilIdle();
 807   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
 808                                           arraysize(kWriteData) - 8));
 809   message_loop_.RunUntilIdle();
 810
 811   ExpectSignalSocketState(
 812       SignalSocketState(
 813           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 814           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 815 }
 816
 817 TEST_F(ChromeAsyncSocketTest, LargeWrite) {
 818   EXPECT_DEBUG_DEATH({
 819     DoOpenClosed();
 820
 821     std::string large_data(100, 'x');
 822     EXPECT_FALSE(chrome_async_socket_->Write(large_data.data(),
 823                                              large_data.size()));
 824     ExpectState(ChromeAsyncSocket::STATE_OPEN,
 825                 ChromeAsyncSocket::ERROR_WINSOCK,
 826                 net::ERR_INSUFFICIENT_RESOURCES);
 827     DoCloseOpened(
 828         SignalSocketState(
 829             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 830             ChromeAsyncSocket::ERROR_WINSOCK,
 831             net::ERR_INSUFFICIENT_RESOURCES));
 832     }, "exceed the max write buffer");
 833 }
 834
 835 TEST_F(ChromeAsyncSocketTest, LargeAccumulatedWrite) {
 836   EXPECT_DEBUG_DEATH({
 837     DoOpenClosed();
 838
 839     std::string data(15, 'x');
 840     EXPECT_TRUE(chrome_async_socket_->Write(data.data(), data.size()));
 841     EXPECT_FALSE(chrome_async_socket_->Write(data.data(), data.size()));
 842     ExpectState(ChromeAsyncSocket::STATE_OPEN,
 843                 ChromeAsyncSocket::ERROR_WINSOCK,
 844                 net::ERR_INSUFFICIENT_RESOURCES);
 845     DoCloseOpened(
 846         SignalSocketState(
 847             SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 848             ChromeAsyncSocket::ERROR_WINSOCK,
 849             net::ERR_INSUFFICIENT_RESOURCES));
 850     }, "exceed the max write buffer");
 851 }
 852
 853 // After this we can assume non-SSL I/O works as expected.
 854
 855 TEST_F(ChromeAsyncSocketTest, HangingSSLConnect) {
 856   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 857   DoOpenClosed();
 858   ExpectReadSignal();
 859
 860   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 861   ExpectNoSignal();
 862
 863   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_CONNECTING);
 864   EXPECT_TRUE(chrome_async_socket_->Close());
 865   ExpectSignalSocketState(
 866       SignalSocketState::NoError(SIGNAL_CLOSE,
 867                                  ChromeAsyncSocket::STATE_CLOSED));
 868   ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED);
 869 }
 870
 871 TEST_F(ChromeAsyncSocketTest, ImmediateSSLConnect) {
 872   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 873   DoOpenClosed();
 874   ExpectReadSignal();
 875
 876   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 877   message_loop_.RunUntilIdle();
 878   ExpectSSLConnectSignal();
 879   ExpectNoSignal();
 880   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 881
 882   DoSSLCloseOpenedNoError();
 883 }
 884
 885 TEST_F(ChromeAsyncSocketTest, DoubleSSLConnect) {
 886   EXPECT_DEBUG_DEATH({
 887     async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 888     DoOpenClosed();
 889     ExpectReadSignal();
 890
 891     EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 892     message_loop_.RunUntilIdle();
 893     ExpectSSLConnectSignal();
 894     ExpectNoSignal();
 895     ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 896
 897     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
 898
 899     DoSSLCloseOpened(
 900         SignalSocketState(SIGNAL_CLOSE,
 901                           ChromeAsyncSocket::STATE_CLOSED,
 902                           ChromeAsyncSocket::ERROR_WRONGSTATE,
 903                           net::OK));
 904   }, "wrong state");
 905 }
 906
 907 TEST_F(ChromeAsyncSocketTest, FailedSSLConnect) {
 908   ssl_socket_data_provider_.connect =
 909       net::MockConnect(net::ASYNC, net::ERR_CERT_COMMON_NAME_INVALID),
 910
 911   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 912   DoOpenClosed();
 913   ExpectReadSignal();
 914
 915   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 916   message_loop_.RunUntilIdle();
 917   ExpectSignalSocketState(
 918       SignalSocketState(
 919           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
 920           ChromeAsyncSocket::ERROR_WINSOCK,
 921           net::ERR_CERT_COMMON_NAME_INVALID));
 922
 923   EXPECT_TRUE(chrome_async_socket_->Close());
 924   ExpectClosed();
 925 }
 926
 927 TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) {
 928   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 929   DoOpenClosed();
 930   ExpectReadSignal();
 931   EXPECT_EQ(kReadData, DrainRead(1));
 932
 933   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 934   ExpectNoSignal();
 935
 936   // Shouldn't do anything.
 937   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 938
 939   char buf[4096];
 940   size_t len_read = 10000U;
 941   EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
 942   EXPECT_EQ(0U, len_read);
 943
 944   message_loop_.RunUntilIdle();
 945   ExpectSSLConnectSignal();
 946   ExpectSSLReadSignal();
 947   ExpectNoSignal();
 948   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN);
 949
 950   len_read = 10000U;
 951   EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read));
 952   EXPECT_EQ(kReadData, std::string(buf, len_read));
 953
 954   DoSSLCloseOpenedNoError();
 955 }
 956
 957 TEST_F(ChromeAsyncSocketTest, WriteDuringSSLConnecting) {
 958   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
 959   DoOpenClosed();
 960   ExpectReadSignal();
 961
 962   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
 963   ExpectNoSignal();
 964   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_CONNECTING);
 965
 966   async_socket_data_provider_.AddWrite(
 967       net::MockWrite(net::ASYNC, kWriteData, 3));
 968
 969   // Shouldn't do anything.
 970   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 971
 972   // TODO(akalin): Figure out how to test that the write happens
 973   // *after* the SSL connect.
 974
 975   message_loop_.RunUntilIdle();
 976   ExpectSSLConnectSignal();
 977   ExpectNoSignal();
 978
 979   message_loop_.RunUntilIdle();
 980
 981   DoSSLCloseOpenedNoError();
 982 }
 983
 984 TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPendingRead) {
 985   EXPECT_DEBUG_DEATH({
 986     DoOpenClosed();
 987
 988     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
 989
 990     DoCloseOpened(
 991         SignalSocketState(SIGNAL_CLOSE,
 992                           ChromeAsyncSocket::STATE_CLOSED,
 993                           ChromeAsyncSocket::ERROR_WRONGSTATE,
 994                           net::OK));
 995   }, "wrong state");
 996 }
 997
 998 TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPostedWrite) {
 999   EXPECT_DEBUG_DEATH({
1000     DoOpenClosed();
1001
1002     async_socket_data_provider_.AddWrite(
1003         net::MockWrite(net::ASYNC, kWriteData, 3));
1004     EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
1005
1006     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
1007
1008     message_loop_.RunUntilIdle();
1009
1010     DoCloseOpened(
1011         SignalSocketState(SIGNAL_CLOSE,
1012                           ChromeAsyncSocket::STATE_CLOSED,
1013                           ChromeAsyncSocket::ERROR_WRONGSTATE,
1014                           net::OK));
1015   }, "wrong state");
1016 }
1017
1018 // After this we can assume SSL connect works as expected.
1019
1020 TEST_F(ChromeAsyncSocketTest, SSLRead) {
1021   DoSSLOpenClosed();
1022   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1023   message_loop_.RunUntilIdle();
1024
1025   ExpectSSLReadSignal();
1026   ExpectNoSignal();
1027
1028   EXPECT_EQ(kReadData, DrainRead(1));
1029
1030   message_loop_.RunUntilIdle();
1031
1032   DoSSLCloseOpenedNoError();
1033 }
1034
1035 TEST_F(ChromeAsyncSocketTest, SSLSyncWrite) {
1036   async_socket_data_provider_.AddWrite(
1037       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
1038   async_socket_data_provider_.AddWrite(
1039       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
1040   async_socket_data_provider_.AddWrite(
1041       net::MockWrite(net::SYNCHRONOUS,
1042                      kWriteData + 8, arraysize(kWriteData) - 8));
1043   DoSSLOpenClosed();
1044
1045   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
1046   message_loop_.RunUntilIdle();
1047   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
1048   message_loop_.RunUntilIdle();
1049   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
1050                                           arraysize(kWriteData) - 8));
1051   message_loop_.RunUntilIdle();
1052
1053   ExpectNoSignal();
1054
1055   DoSSLCloseOpenedNoError();
1056 }
1057
1058 TEST_F(ChromeAsyncSocketTest, SSLAsyncWrite) {
1059   DoSSLOpenClosed();
1060
1061   async_socket_data_provider_.AddWrite(
1062       net::MockWrite(net::ASYNC, kWriteData, 3));
1063   async_socket_data_provider_.AddWrite(
1064       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
1065   async_socket_data_provider_.AddWrite(
1066       net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
1067
1068   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
1069   message_loop_.RunUntilIdle();
1070   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
1071   message_loop_.RunUntilIdle();
1072   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
1073                                           arraysize(kWriteData) - 8));
1074   message_loop_.RunUntilIdle();
1075
1076   ExpectNoSignal();
1077
1078   DoSSLCloseOpenedNoError();
1079 }
1080
1081 }  // namespace
1082
1083 }  // namespace jingle_glue