Home | History | Annotate | Download | only in socket_stream 
      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 "net/socket_stream/socket_stream.h"
      6 
      7 #include <string>
      8 #include <vector>
      9 
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/callback.h"
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "net/base/auth.h"
     15 #include "net/base/net_log.h"
     16 #include "net/base/net_log_unittest.h"
     17 #include "net/base/test_completion_callback.h"
     18 #include "net/dns/mock_host_resolver.h"
     19 #include "net/http/http_network_session.h"
     20 #include "net/proxy/proxy_service.h"
     21 #include "net/socket/socket_test_util.h"
     22 #include "net/url_request/url_request_test_util.h"
     23 #include "testing/gtest/include/gtest/gtest.h"
     24 #include "testing/platform_test.h"
     25 
     26 namespace net {
     27 
     28 namespace {
     29 
     30 struct SocketStreamEvent {
     31   enum EventType {
     32     EVENT_START_OPEN_CONNECTION, EVENT_CONNECTED, EVENT_SENT_DATA,
     33     EVENT_RECEIVED_DATA, EVENT_CLOSE, EVENT_AUTH_REQUIRED, EVENT_ERROR,
     34   };
     35 
     36   SocketStreamEvent(EventType type,
     37                     SocketStream* socket_stream,
     38                     int num,
     39                     const std::string& str,
     40                     AuthChallengeInfo* auth_challenge_info,
     41                     int error)
     42       : event_type(type), socket(socket_stream), number(num), data(str),
     43         auth_info(auth_challenge_info), error_code(error) {}
     44 
     45   EventType event_type;
     46   SocketStream* socket;
     47   int number;
     48   std::string data;
     49   scoped_refptr<AuthChallengeInfo> auth_info;
     50   int error_code;
     51 };
     52 
     53 class SocketStreamEventRecorder : public SocketStream::Delegate {
     54  public:
     55   // |callback| will be run when the OnClose() or OnError() method is called.
     56   // For OnClose(), |callback| is called with OK. For OnError(), it's called
     57   // with the error code.
     58   explicit SocketStreamEventRecorder(const CompletionCallback& callback)
     59       : callback_(callback) {}
     60   virtual ~SocketStreamEventRecorder() {}
     61 
     62   void SetOnStartOpenConnection(
     63       const base::Callback<int(SocketStreamEvent*)>& callback) {
     64     on_start_open_connection_ = callback;
     65   }
     66   void SetOnConnected(
     67       const base::Callback<void(SocketStreamEvent*)>& callback) {
     68     on_connected_ = callback;
     69   }
     70   void SetOnSentData(
     71       const base::Callback<void(SocketStreamEvent*)>& callback) {
     72     on_sent_data_ = callback;
     73   }
     74   void SetOnReceivedData(
     75       const base::Callback<void(SocketStreamEvent*)>& callback) {
     76     on_received_data_ = callback;
     77   }
     78   void SetOnClose(const base::Callback<void(SocketStreamEvent*)>& callback) {
     79     on_close_ = callback;
     80   }
     81   void SetOnAuthRequired(
     82       const base::Callback<void(SocketStreamEvent*)>& callback) {
     83     on_auth_required_ = callback;
     84   }
     85   void SetOnError(const base::Callback<void(SocketStreamEvent*)>& callback) {
     86     on_error_ = callback;
     87   }
     88 
     89   virtual int OnStartOpenConnection(
     90       SocketStream* socket,
     91       const CompletionCallback& callback) OVERRIDE {
     92     connection_callback_ = callback;
     93     events_.push_back(
     94         SocketStreamEvent(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
     95                           socket, 0, std::string(), NULL, OK));
     96     if (!on_start_open_connection_.is_null())
     97       return on_start_open_connection_.Run(&events_.back());
     98     return OK;
     99   }
    100   virtual void OnConnected(SocketStream* socket,
    101                            int num_pending_send_allowed) OVERRIDE {
    102     events_.push_back(
    103         SocketStreamEvent(SocketStreamEvent::EVENT_CONNECTED,
    104                           socket, num_pending_send_allowed, std::string(),
    105                           NULL, OK));
    106     if (!on_connected_.is_null())
    107       on_connected_.Run(&events_.back());
    108   }
    109   virtual void OnSentData(SocketStream* socket,
    110                           int amount_sent) OVERRIDE {
    111     events_.push_back(
    112         SocketStreamEvent(SocketStreamEvent::EVENT_SENT_DATA, socket,
    113                           amount_sent, std::string(), NULL, OK));
    114     if (!on_sent_data_.is_null())
    115       on_sent_data_.Run(&events_.back());
    116   }
    117   virtual void OnReceivedData(SocketStream* socket,
    118                               const char* data, int len) OVERRIDE {
    119     events_.push_back(
    120         SocketStreamEvent(SocketStreamEvent::EVENT_RECEIVED_DATA, socket, len,
    121                           std::string(data, len), NULL, OK));
    122     if (!on_received_data_.is_null())
    123       on_received_data_.Run(&events_.back());
    124   }
    125   virtual void OnClose(SocketStream* socket) OVERRIDE {
    126     events_.push_back(
    127         SocketStreamEvent(SocketStreamEvent::EVENT_CLOSE, socket, 0,
    128                           std::string(), NULL, OK));
    129     if (!on_close_.is_null())
    130       on_close_.Run(&events_.back());
    131     if (!callback_.is_null())
    132       callback_.Run(OK);
    133   }
    134   virtual void OnAuthRequired(SocketStream* socket,
    135                               AuthChallengeInfo* auth_info) OVERRIDE {
    136     events_.push_back(
    137         SocketStreamEvent(SocketStreamEvent::EVENT_AUTH_REQUIRED, socket, 0,
    138                           std::string(), auth_info, OK));
    139     if (!on_auth_required_.is_null())
    140       on_auth_required_.Run(&events_.back());
    141   }
    142   virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
    143     events_.push_back(
    144         SocketStreamEvent(SocketStreamEvent::EVENT_ERROR, NULL, 0,
    145                           std::string(), NULL, error));
    146     if (!on_error_.is_null())
    147       on_error_.Run(&events_.back());
    148     if (!callback_.is_null())
    149       callback_.Run(error);
    150   }
    151 
    152   void DoClose(SocketStreamEvent* event) {
    153     event->socket->Close();
    154   }
    155   void DoRestartWithAuth(SocketStreamEvent* event) {
    156     VLOG(1) << "RestartWithAuth username=" << credentials_.username()
    157             << " password=" << credentials_.password();
    158     event->socket->RestartWithAuth(credentials_);
    159   }
    160   void SetAuthInfo(const AuthCredentials& credentials) {
    161     credentials_ = credentials;
    162   }
    163   // Wakes up the SocketStream waiting for completion of OnStartOpenConnection()
    164   // of its delegate.
    165   void CompleteConnection(int result) {
    166     connection_callback_.Run(result);
    167   }
    168 
    169   const std::vector<SocketStreamEvent>& GetSeenEvents() const {
    170     return events_;
    171   }
    172 
    173  private:
    174   std::vector<SocketStreamEvent> events_;
    175   base::Callback<int(SocketStreamEvent*)> on_start_open_connection_;
    176   base::Callback<void(SocketStreamEvent*)> on_connected_;
    177   base::Callback<void(SocketStreamEvent*)> on_sent_data_;
    178   base::Callback<void(SocketStreamEvent*)> on_received_data_;
    179   base::Callback<void(SocketStreamEvent*)> on_close_;
    180   base::Callback<void(SocketStreamEvent*)> on_auth_required_;
    181   base::Callback<void(SocketStreamEvent*)> on_error_;
    182   const CompletionCallback callback_;
    183   CompletionCallback connection_callback_;
    184   AuthCredentials credentials_;
    185 
    186   DISALLOW_COPY_AND_ASSIGN(SocketStreamEventRecorder);
    187 };
    188 
    189 // This is used for the test OnErrorDetachDelegate.
    190 class SelfDeletingDelegate : public SocketStream::Delegate {
    191  public:
    192   // |callback| must cause the test message loop to exit when called.
    193   explicit SelfDeletingDelegate(const CompletionCallback& callback)
    194       : socket_stream_(), callback_(callback) {}
    195 
    196   virtual ~SelfDeletingDelegate() {}
    197 
    198   // Call DetachDelegate(), delete |this|, then run the callback.
    199   virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
    200     // callback_ will be deleted when we delete |this|, so copy it to call it
    201     // afterwards.
    202     CompletionCallback callback = callback_;
    203     socket_stream_->DetachDelegate();
    204     delete this;
    205     callback.Run(OK);
    206   }
    207 
    208   // This can't be passed in the constructor because this object needs to be
    209   // created before SocketStream.
    210   void set_socket_stream(const scoped_refptr<SocketStream>& socket_stream) {
    211     socket_stream_ = socket_stream;
    212     EXPECT_EQ(socket_stream_->delegate(), this);
    213   }
    214 
    215   virtual void OnConnected(SocketStream* socket, int max_pending_send_allowed)
    216       OVERRIDE {
    217     ADD_FAILURE() << "OnConnected() should not be called";
    218   }
    219   virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
    220     ADD_FAILURE() << "OnSentData() should not be called";
    221   }
    222   virtual void OnReceivedData(SocketStream* socket, const char* data, int len)
    223       OVERRIDE {
    224     ADD_FAILURE() << "OnReceivedData() should not be called";
    225   }
    226   virtual void OnClose(SocketStream* socket) OVERRIDE {
    227     ADD_FAILURE() << "OnClose() should not be called";
    228   }
    229 
    230  private:
    231   scoped_refptr<SocketStream> socket_stream_;
    232   const CompletionCallback callback_;
    233 
    234   DISALLOW_COPY_AND_ASSIGN(SelfDeletingDelegate);
    235 };
    236 
    237 class TestURLRequestContextWithProxy : public TestURLRequestContext {
    238  public:
    239   explicit TestURLRequestContextWithProxy(const std::string& proxy)
    240       : TestURLRequestContext(true) {
    241     context_storage_.set_proxy_service(ProxyService::CreateFixed(proxy));
    242     Init();
    243   }
    244   virtual ~TestURLRequestContextWithProxy() {}
    245 };
    246 
    247 class TestSocketStreamNetworkDelegate : public TestNetworkDelegate {
    248  public:
    249   TestSocketStreamNetworkDelegate()
    250       : before_connect_result_(OK) {}
    251   virtual ~TestSocketStreamNetworkDelegate() {}
    252 
    253   virtual int OnBeforeSocketStreamConnect(
    254       SocketStream* stream,
    255       const CompletionCallback& callback) OVERRIDE {
    256     return before_connect_result_;
    257   }
    258 
    259   void SetBeforeConnectResult(int result) {
    260     before_connect_result_ = result;
    261   }
    262 
    263  private:
    264   int before_connect_result_;
    265 };
    266 
    267 }  // namespace
    268 
    269 class SocketStreamTest : public PlatformTest {
    270  public:
    271   virtual ~SocketStreamTest() {}
    272   virtual void SetUp() {
    273     mock_socket_factory_.reset();
    274     handshake_request_ = kWebSocketHandshakeRequest;
    275     handshake_response_ = kWebSocketHandshakeResponse;
    276   }
    277   virtual void TearDown() {
    278     mock_socket_factory_.reset();
    279   }
    280 
    281   virtual void SetWebSocketHandshakeMessage(
    282       const char* request, const char* response) {
    283     handshake_request_ = request;
    284     handshake_response_ = response;
    285   }
    286   virtual void AddWebSocketMessage(const std::string& message) {
    287     messages_.push_back(message);
    288   }
    289 
    290   virtual MockClientSocketFactory* GetMockClientSocketFactory() {
    291     mock_socket_factory_.reset(new MockClientSocketFactory);
    292     return mock_socket_factory_.get();
    293   }
    294 
    295   // Functions for SocketStreamEventRecorder to handle calls to the
    296   // SocketStream::Delegate methods from the SocketStream.
    297 
    298   virtual void DoSendWebSocketHandshake(SocketStreamEvent* event) {
    299     event->socket->SendData(
    300         handshake_request_.data(), handshake_request_.size());
    301   }
    302 
    303   virtual void DoCloseFlushPendingWriteTest(SocketStreamEvent* event) {
    304     // handshake response received.
    305     for (size_t i = 0; i < messages_.size(); i++) {
    306       std::vector<char> frame;
    307       frame.push_back('\0');
    308       frame.insert(frame.end(), messages_[i].begin(), messages_[i].end());
    309       frame.push_back('\xff');
    310       EXPECT_TRUE(event->socket->SendData(&frame[0], frame.size()));
    311     }
    312     // Actual StreamSocket close must happen after all frames queued by
    313     // SendData above are sent out.
    314     event->socket->Close();
    315   }
    316 
    317   virtual void DoCloseFlushPendingWriteTestWithSetContextNull(
    318       SocketStreamEvent* event) {
    319     event->socket->set_context(NULL);
    320     // handshake response received.
    321     for (size_t i = 0; i < messages_.size(); i++) {
    322       std::vector<char> frame;
    323       frame.push_back('\0');
    324       frame.insert(frame.end(), messages_[i].begin(), messages_[i].end());
    325       frame.push_back('\xff');
    326       EXPECT_TRUE(event->socket->SendData(&frame[0], frame.size()));
    327     }
    328     // Actual StreamSocket close must happen after all frames queued by
    329     // SendData above are sent out.
    330     event->socket->Close();
    331   }
    332 
    333   virtual void DoFailByTooBigDataAndClose(SocketStreamEvent* event) {
    334     std::string frame(event->number + 1, 0x00);
    335     VLOG(1) << event->number;
    336     EXPECT_FALSE(event->socket->SendData(&frame[0], frame.size()));
    337     event->socket->Close();
    338   }
    339 
    340   virtual int DoSwitchToSpdyTest(SocketStreamEvent* event) {
    341     return ERR_PROTOCOL_SWITCHED;
    342   }
    343 
    344   // Notifies |io_test_callback_| of that this method is called, and keeps the
    345   // SocketStream waiting.
    346   virtual int DoIOPending(SocketStreamEvent* event) {
    347     io_test_callback_.callback().Run(OK);
    348     return ERR_IO_PENDING;
    349   }
    350 
    351   static const char kWebSocketHandshakeRequest[];
    352   static const char kWebSocketHandshakeResponse[];
    353 
    354  protected:
    355   TestCompletionCallback io_test_callback_;
    356 
    357  private:
    358   std::string handshake_request_;
    359   std::string handshake_response_;
    360   std::vector<std::string> messages_;
    361 
    362   scoped_ptr<MockClientSocketFactory> mock_socket_factory_;
    363 };
    364 
    365 const char SocketStreamTest::kWebSocketHandshakeRequest[] =
    366     "GET /demo HTTP/1.1\r\n"
    367     "Host: example.com\r\n"
    368     "Connection: Upgrade\r\n"
    369     "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
    370     "Sec-WebSocket-Protocol: sample\r\n"
    371     "Upgrade: WebSocket\r\n"
    372     "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
    373     "Origin: http://example.com\r\n"
    374     "\r\n"
    375     "^n:ds[4U";
    376 
    377 const char SocketStreamTest::kWebSocketHandshakeResponse[] =
    378     "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
    379     "Upgrade: WebSocket\r\n"
    380     "Connection: Upgrade\r\n"
    381     "Sec-WebSocket-Origin: http://example.com\r\n"
    382     "Sec-WebSocket-Location: ws://example.com/demo\r\n"
    383     "Sec-WebSocket-Protocol: sample\r\n"
    384     "\r\n"
    385     "8jKS'y:G*Co,Wxa-";
    386 
    387 TEST_F(SocketStreamTest, CloseFlushPendingWrite) {
    388   TestCompletionCallback test_callback;
    389 
    390   scoped_ptr<SocketStreamEventRecorder> delegate(
    391       new SocketStreamEventRecorder(test_callback.callback()));
    392   delegate->SetOnConnected(base::Bind(
    393       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
    394   delegate->SetOnReceivedData(base::Bind(
    395       &SocketStreamTest::DoCloseFlushPendingWriteTest,
    396       base::Unretained(this)));
    397 
    398   TestURLRequestContext context;
    399 
    400   scoped_refptr<SocketStream> socket_stream(
    401       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    402 
    403   socket_stream->set_context(&context);
    404 
    405   MockWrite data_writes[] = {
    406     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
    407     MockWrite(ASYNC, "\0message1\xff", 10),
    408     MockWrite(ASYNC, "\0message2\xff", 10)
    409   };
    410   MockRead data_reads[] = {
    411     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
    412     // Server doesn't close the connection after handshake.
    413     MockRead(ASYNC, ERR_IO_PENDING)
    414   };
    415   AddWebSocketMessage("message1");
    416   AddWebSocketMessage("message2");
    417 
    418   DelayedSocketData data_provider(
    419       1, data_reads, arraysize(data_reads),
    420       data_writes, arraysize(data_writes));
    421 
    422   MockClientSocketFactory* mock_socket_factory =
    423       GetMockClientSocketFactory();
    424   mock_socket_factory->AddSocketDataProvider(&data_provider);
    425 
    426   socket_stream->SetClientSocketFactory(mock_socket_factory);
    427 
    428   socket_stream->Connect();
    429 
    430   test_callback.WaitForResult();
    431 
    432   EXPECT_TRUE(data_provider.at_read_eof());
    433   EXPECT_TRUE(data_provider.at_write_eof());
    434 
    435   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    436   ASSERT_EQ(7U, events.size());
    437 
    438   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    439             events[0].event_type);
    440   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    441   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
    442   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
    443   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[4].event_type);
    444   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[5].event_type);
    445   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
    446 }
    447 
    448 TEST_F(SocketStreamTest, ResolveFailure) {
    449   TestCompletionCallback test_callback;
    450 
    451   scoped_ptr<SocketStreamEventRecorder> delegate(
    452       new SocketStreamEventRecorder(test_callback.callback()));
    453 
    454   scoped_refptr<SocketStream> socket_stream(
    455       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    456 
    457   // Make resolver fail.
    458   TestURLRequestContext context;
    459   scoped_ptr<MockHostResolver> mock_host_resolver(
    460       new MockHostResolver());
    461   mock_host_resolver->rules()->AddSimulatedFailure("example.com");
    462   context.set_host_resolver(mock_host_resolver.get());
    463   socket_stream->set_context(&context);
    464 
    465   // No read/write on socket is expected.
    466   StaticSocketDataProvider data_provider(NULL, 0, NULL, 0);
    467   MockClientSocketFactory* mock_socket_factory =
    468       GetMockClientSocketFactory();
    469   mock_socket_factory->AddSocketDataProvider(&data_provider);
    470   socket_stream->SetClientSocketFactory(mock_socket_factory);
    471 
    472   socket_stream->Connect();
    473 
    474   test_callback.WaitForResult();
    475 
    476   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    477   ASSERT_EQ(2U, events.size());
    478 
    479   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[0].event_type);
    480   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[1].event_type);
    481 }
    482 
    483 TEST_F(SocketStreamTest, ExceedMaxPendingSendAllowed) {
    484   TestCompletionCallback test_callback;
    485 
    486   scoped_ptr<SocketStreamEventRecorder> delegate(
    487       new SocketStreamEventRecorder(test_callback.callback()));
    488   delegate->SetOnConnected(base::Bind(
    489       &SocketStreamTest::DoFailByTooBigDataAndClose, base::Unretained(this)));
    490 
    491   TestURLRequestContext context;
    492 
    493   scoped_refptr<SocketStream> socket_stream(
    494       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    495 
    496   socket_stream->set_context(&context);
    497 
    498   DelayedSocketData data_provider(1, NULL, 0, NULL, 0);
    499 
    500   MockClientSocketFactory* mock_socket_factory =
    501       GetMockClientSocketFactory();
    502   mock_socket_factory->AddSocketDataProvider(&data_provider);
    503 
    504   socket_stream->SetClientSocketFactory(mock_socket_factory);
    505 
    506   socket_stream->Connect();
    507 
    508   test_callback.WaitForResult();
    509 
    510   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    511   ASSERT_EQ(4U, events.size());
    512 
    513   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    514             events[0].event_type);
    515   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    516   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[2].event_type);
    517   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
    518 }
    519 
    520 TEST_F(SocketStreamTest, BasicAuthProxy) {
    521   MockClientSocketFactory mock_socket_factory;
    522   MockWrite data_writes1[] = {
    523     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
    524               "Host: example.com\r\n"
    525               "Proxy-Connection: keep-alive\r\n\r\n"),
    526   };
    527   MockRead data_reads1[] = {
    528     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
    529     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
    530     MockRead("\r\n"),
    531   };
    532   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
    533                                  data_writes1, arraysize(data_writes1));
    534   mock_socket_factory.AddSocketDataProvider(&data1);
    535 
    536   MockWrite data_writes2[] = {
    537     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
    538               "Host: example.com\r\n"
    539               "Proxy-Connection: keep-alive\r\n"
    540               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
    541   };
    542   MockRead data_reads2[] = {
    543     MockRead("HTTP/1.1 200 Connection Established\r\n"),
    544     MockRead("Proxy-agent: Apache/2.2.8\r\n"),
    545     MockRead("\r\n"),
    546     // SocketStream::DoClose is run asynchronously.  Socket can be read after
    547     // "\r\n".  We have to give ERR_IO_PENDING to SocketStream then to indicate
    548     // server doesn't close the connection.
    549     MockRead(ASYNC, ERR_IO_PENDING)
    550   };
    551   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
    552                                  data_writes2, arraysize(data_writes2));
    553   mock_socket_factory.AddSocketDataProvider(&data2);
    554 
    555   TestCompletionCallback test_callback;
    556 
    557   scoped_ptr<SocketStreamEventRecorder> delegate(
    558       new SocketStreamEventRecorder(test_callback.callback()));
    559   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
    560                                       base::Unretained(delegate.get())));
    561   delegate->SetAuthInfo(AuthCredentials(ASCIIToUTF16("foo"),
    562                                         ASCIIToUTF16("bar")));
    563   delegate->SetOnAuthRequired(base::Bind(
    564       &SocketStreamEventRecorder::DoRestartWithAuth,
    565       base::Unretained(delegate.get())));
    566 
    567   scoped_refptr<SocketStream> socket_stream(
    568       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    569 
    570   TestURLRequestContextWithProxy context("myproxy:70");
    571 
    572   socket_stream->set_context(&context);
    573   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    574 
    575   socket_stream->Connect();
    576 
    577   test_callback.WaitForResult();
    578 
    579   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    580   ASSERT_EQ(5U, events.size());
    581 
    582   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    583             events[0].event_type);
    584   EXPECT_EQ(SocketStreamEvent::EVENT_AUTH_REQUIRED, events[1].event_type);
    585   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[2].event_type);
    586   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[3].event_type);
    587   EXPECT_EQ(ERR_ABORTED, events[3].error_code);
    588   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[4].event_type);
    589 
    590   // TODO(eroman): Add back NetLogTest here...
    591 }
    592 
    593 TEST_F(SocketStreamTest, BasicAuthProxyWithAuthCache) {
    594   MockClientSocketFactory mock_socket_factory;
    595   MockWrite data_writes[] = {
    596     // WebSocket(SocketStream) always uses CONNECT when it is configured to use
    597     // proxy so the port may not be 443.
    598     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
    599               "Host: example.com\r\n"
    600               "Proxy-Connection: keep-alive\r\n"
    601               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
    602   };
    603   MockRead data_reads[] = {
    604     MockRead("HTTP/1.1 200 Connection Established\r\n"),
    605     MockRead("Proxy-agent: Apache/2.2.8\r\n"),
    606     MockRead("\r\n"),
    607     MockRead(ASYNC, ERR_IO_PENDING)
    608   };
    609   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    610                                  data_writes, arraysize(data_writes));
    611   mock_socket_factory.AddSocketDataProvider(&data);
    612 
    613   TestCompletionCallback test_callback;
    614   scoped_ptr<SocketStreamEventRecorder> delegate(
    615       new SocketStreamEventRecorder(test_callback.callback()));
    616   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
    617                                       base::Unretained(delegate.get())));
    618 
    619   scoped_refptr<SocketStream> socket_stream(
    620       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    621 
    622   TestURLRequestContextWithProxy context("myproxy:70");
    623   HttpAuthCache* auth_cache =
    624       context.http_transaction_factory()->GetSession()->http_auth_cache();
    625   auth_cache->Add(GURL("http://myproxy:70"),
    626                   "MyRealm1",
    627                   HttpAuth::AUTH_SCHEME_BASIC,
    628                   "Basic realm=MyRealm1",
    629                   AuthCredentials(ASCIIToUTF16("foo"),
    630                                   ASCIIToUTF16("bar")),
    631                   "/");
    632 
    633   socket_stream->set_context(&context);
    634   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    635 
    636   socket_stream->Connect();
    637 
    638   test_callback.WaitForResult();
    639 
    640   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    641   ASSERT_EQ(4U, events.size());
    642   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    643             events[0].event_type);
    644   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    645   EXPECT_EQ(ERR_ABORTED, events[2].error_code);
    646   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
    647 }
    648 
    649 TEST_F(SocketStreamTest, WSSBasicAuthProxyWithAuthCache) {
    650   MockClientSocketFactory mock_socket_factory;
    651   MockWrite data_writes1[] = {
    652     MockWrite("CONNECT example.com:443 HTTP/1.1\r\n"
    653               "Host: example.com\r\n"
    654               "Proxy-Connection: keep-alive\r\n"
    655               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
    656   };
    657   MockRead data_reads1[] = {
    658     MockRead("HTTP/1.1 200 Connection Established\r\n"),
    659     MockRead("Proxy-agent: Apache/2.2.8\r\n"),
    660     MockRead("\r\n"),
    661     MockRead(ASYNC, ERR_IO_PENDING)
    662   };
    663   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
    664                                  data_writes1, arraysize(data_writes1));
    665   mock_socket_factory.AddSocketDataProvider(&data1);
    666 
    667   SSLSocketDataProvider data2(ASYNC, OK);
    668   mock_socket_factory.AddSSLSocketDataProvider(&data2);
    669 
    670   TestCompletionCallback test_callback;
    671   scoped_ptr<SocketStreamEventRecorder> delegate(
    672       new SocketStreamEventRecorder(test_callback.callback()));
    673   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
    674                                       base::Unretained(delegate.get())));
    675 
    676   scoped_refptr<SocketStream> socket_stream(
    677       new SocketStream(GURL("wss://example.com/demo"), delegate.get()));
    678 
    679   TestURLRequestContextWithProxy context("myproxy:70");
    680   HttpAuthCache* auth_cache =
    681       context.http_transaction_factory()->GetSession()->http_auth_cache();
    682   auth_cache->Add(GURL("http://myproxy:70"),
    683                   "MyRealm1",
    684                   HttpAuth::AUTH_SCHEME_BASIC,
    685                   "Basic realm=MyRealm1",
    686                   AuthCredentials(ASCIIToUTF16("foo"),
    687                                   ASCIIToUTF16("bar")),
    688                   "/");
    689 
    690   socket_stream->set_context(&context);
    691   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    692 
    693   socket_stream->Connect();
    694 
    695   test_callback.WaitForResult();
    696 
    697   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    698   ASSERT_EQ(4U, events.size());
    699   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    700             events[0].event_type);
    701   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    702   EXPECT_EQ(ERR_ABORTED, events[2].error_code);
    703   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
    704 }
    705 
    706 TEST_F(SocketStreamTest, IOPending) {
    707   TestCompletionCallback test_callback;
    708 
    709   scoped_ptr<SocketStreamEventRecorder> delegate(
    710       new SocketStreamEventRecorder(test_callback.callback()));
    711   delegate->SetOnStartOpenConnection(base::Bind(
    712       &SocketStreamTest::DoIOPending, base::Unretained(this)));
    713   delegate->SetOnConnected(base::Bind(
    714       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
    715   delegate->SetOnReceivedData(base::Bind(
    716       &SocketStreamTest::DoCloseFlushPendingWriteTest,
    717       base::Unretained(this)));
    718 
    719   TestURLRequestContext context;
    720 
    721   scoped_refptr<SocketStream> socket_stream(
    722       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    723 
    724   socket_stream->set_context(&context);
    725 
    726   MockWrite data_writes[] = {
    727     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
    728     MockWrite(ASYNC, "\0message1\xff", 10),
    729     MockWrite(ASYNC, "\0message2\xff", 10)
    730   };
    731   MockRead data_reads[] = {
    732     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
    733     // Server doesn't close the connection after handshake.
    734     MockRead(ASYNC, ERR_IO_PENDING)
    735   };
    736   AddWebSocketMessage("message1");
    737   AddWebSocketMessage("message2");
    738 
    739   DelayedSocketData data_provider(
    740       1, data_reads, arraysize(data_reads),
    741       data_writes, arraysize(data_writes));
    742 
    743   MockClientSocketFactory* mock_socket_factory =
    744       GetMockClientSocketFactory();
    745   mock_socket_factory->AddSocketDataProvider(&data_provider);
    746 
    747   socket_stream->SetClientSocketFactory(mock_socket_factory);
    748 
    749   socket_stream->Connect();
    750   io_test_callback_.WaitForResult();
    751   EXPECT_EQ(SocketStream::STATE_RESOLVE_PROTOCOL_COMPLETE,
    752             socket_stream->next_state_);
    753   delegate->CompleteConnection(OK);
    754 
    755   EXPECT_EQ(OK, test_callback.WaitForResult());
    756 
    757   EXPECT_TRUE(data_provider.at_read_eof());
    758   EXPECT_TRUE(data_provider.at_write_eof());
    759 
    760   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    761   ASSERT_EQ(7U, events.size());
    762 
    763   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    764             events[0].event_type);
    765   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    766   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
    767   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
    768   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[4].event_type);
    769   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[5].event_type);
    770   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
    771 }
    772 
    773 TEST_F(SocketStreamTest, SwitchToSpdy) {
    774   TestCompletionCallback test_callback;
    775 
    776   scoped_ptr<SocketStreamEventRecorder> delegate(
    777       new SocketStreamEventRecorder(test_callback.callback()));
    778   delegate->SetOnStartOpenConnection(base::Bind(
    779       &SocketStreamTest::DoSwitchToSpdyTest, base::Unretained(this)));
    780 
    781   TestURLRequestContext context;
    782 
    783   scoped_refptr<SocketStream> socket_stream(
    784       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    785 
    786   socket_stream->set_context(&context);
    787 
    788   socket_stream->Connect();
    789 
    790   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, test_callback.WaitForResult());
    791 
    792   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    793   ASSERT_EQ(2U, events.size());
    794 
    795   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    796             events[0].event_type);
    797   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
    798   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, events[1].error_code);
    799 }
    800 
    801 TEST_F(SocketStreamTest, SwitchAfterPending) {
    802   TestCompletionCallback test_callback;
    803 
    804   scoped_ptr<SocketStreamEventRecorder> delegate(
    805       new SocketStreamEventRecorder(test_callback.callback()));
    806   delegate->SetOnStartOpenConnection(base::Bind(
    807       &SocketStreamTest::DoIOPending, base::Unretained(this)));
    808 
    809   TestURLRequestContext context;
    810 
    811   scoped_refptr<SocketStream> socket_stream(
    812       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    813 
    814   socket_stream->set_context(&context);
    815 
    816   socket_stream->Connect();
    817   io_test_callback_.WaitForResult();
    818 
    819   EXPECT_EQ(SocketStream::STATE_RESOLVE_PROTOCOL_COMPLETE,
    820             socket_stream->next_state_);
    821   delegate->CompleteConnection(ERR_PROTOCOL_SWITCHED);
    822 
    823   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, test_callback.WaitForResult());
    824 
    825   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    826   ASSERT_EQ(2U, events.size());
    827 
    828   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    829             events[0].event_type);
    830   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
    831   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, events[1].error_code);
    832 }
    833 
    834 // Test a connection though a secure proxy.
    835 TEST_F(SocketStreamTest, SecureProxyConnectError) {
    836   MockClientSocketFactory mock_socket_factory;
    837   MockWrite data_writes[] = {
    838     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
    839               "Host: example.com\r\n"
    840               "Proxy-Connection: keep-alive\r\n\r\n")
    841   };
    842   MockRead data_reads[] = {
    843     MockRead("HTTP/1.1 200 Connection Established\r\n"),
    844     MockRead("Proxy-agent: Apache/2.2.8\r\n"),
    845     MockRead("\r\n"),
    846     // SocketStream::DoClose is run asynchronously.  Socket can be read after
    847     // "\r\n".  We have to give ERR_IO_PENDING to SocketStream then to indicate
    848     // server doesn't close the connection.
    849     MockRead(ASYNC, ERR_IO_PENDING)
    850   };
    851   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    852                                 data_writes, arraysize(data_writes));
    853   mock_socket_factory.AddSocketDataProvider(&data);
    854   SSLSocketDataProvider ssl(SYNCHRONOUS, ERR_SSL_PROTOCOL_ERROR);
    855   mock_socket_factory.AddSSLSocketDataProvider(&ssl);
    856 
    857   TestCompletionCallback test_callback;
    858   TestURLRequestContextWithProxy context("https://myproxy:70");
    859 
    860   scoped_ptr<SocketStreamEventRecorder> delegate(
    861       new SocketStreamEventRecorder(test_callback.callback()));
    862   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
    863                                       base::Unretained(delegate.get())));
    864 
    865   scoped_refptr<SocketStream> socket_stream(
    866       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    867 
    868   socket_stream->set_context(&context);
    869   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    870 
    871   socket_stream->Connect();
    872 
    873   test_callback.WaitForResult();
    874 
    875   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    876   ASSERT_EQ(3U, events.size());
    877 
    878   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    879             events[0].event_type);
    880   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
    881   EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, events[1].error_code);
    882   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[2].event_type);
    883 }
    884 
    885 // Test a connection though a secure proxy.
    886 TEST_F(SocketStreamTest, SecureProxyConnect) {
    887   MockClientSocketFactory mock_socket_factory;
    888   MockWrite data_writes[] = {
    889     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
    890               "Host: example.com\r\n"
    891               "Proxy-Connection: keep-alive\r\n\r\n")
    892   };
    893   MockRead data_reads[] = {
    894     MockRead("HTTP/1.1 200 Connection Established\r\n"),
    895     MockRead("Proxy-agent: Apache/2.2.8\r\n"),
    896     MockRead("\r\n"),
    897     // SocketStream::DoClose is run asynchronously.  Socket can be read after
    898     // "\r\n".  We have to give ERR_IO_PENDING to SocketStream then to indicate
    899     // server doesn't close the connection.
    900     MockRead(ASYNC, ERR_IO_PENDING)
    901   };
    902   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    903                                 data_writes, arraysize(data_writes));
    904   mock_socket_factory.AddSocketDataProvider(&data);
    905   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    906   mock_socket_factory.AddSSLSocketDataProvider(&ssl);
    907 
    908   TestCompletionCallback test_callback;
    909   TestURLRequestContextWithProxy context("https://myproxy:70");
    910 
    911   scoped_ptr<SocketStreamEventRecorder> delegate(
    912       new SocketStreamEventRecorder(test_callback.callback()));
    913   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
    914                                       base::Unretained(delegate.get())));
    915 
    916   scoped_refptr<SocketStream> socket_stream(
    917       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    918 
    919   socket_stream->set_context(&context);
    920   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    921 
    922   socket_stream->Connect();
    923 
    924   test_callback.WaitForResult();
    925 
    926   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    927   ASSERT_EQ(4U, events.size());
    928 
    929   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
    930             events[0].event_type);
    931   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
    932   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[2].event_type);
    933   EXPECT_EQ(ERR_ABORTED, events[2].error_code);
    934   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
    935 }
    936 
    937 TEST_F(SocketStreamTest, BeforeConnectFailed) {
    938   TestCompletionCallback test_callback;
    939 
    940   scoped_ptr<SocketStreamEventRecorder> delegate(
    941       new SocketStreamEventRecorder(test_callback.callback()));
    942 
    943   TestURLRequestContext context;
    944   TestSocketStreamNetworkDelegate network_delegate;
    945   network_delegate.SetBeforeConnectResult(ERR_ACCESS_DENIED);
    946   context.set_network_delegate(&network_delegate);
    947 
    948   scoped_refptr<SocketStream> socket_stream(
    949       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
    950 
    951   socket_stream->set_context(&context);
    952 
    953   socket_stream->Connect();
    954 
    955   test_callback.WaitForResult();
    956 
    957   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
    958   ASSERT_EQ(2U, events.size());
    959 
    960   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[0].event_type);
    961   EXPECT_EQ(ERR_ACCESS_DENIED, events[0].error_code);
    962   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[1].event_type);
    963 }
    964 
    965 // Check that a connect failure, followed by the delegate calling DetachDelegate
    966 // and deleting itself in the OnError callback, is handled correctly.
    967 TEST_F(SocketStreamTest, OnErrorDetachDelegate) {
    968   MockClientSocketFactory mock_socket_factory;
    969   TestCompletionCallback test_callback;
    970 
    971   // SelfDeletingDelegate is self-owning; we just need a pointer to it to
    972   // connect it and the SocketStream.
    973   SelfDeletingDelegate* delegate =
    974       new SelfDeletingDelegate(test_callback.callback());
    975   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
    976   StaticSocketDataProvider data;
    977   data.set_connect_data(mock_connect);
    978   mock_socket_factory.AddSocketDataProvider(&data);
    979 
    980   TestURLRequestContext context;
    981   scoped_refptr<SocketStream> socket_stream(
    982       new SocketStream(GURL("ws://localhost:9998/echo"), delegate));
    983   socket_stream->set_context(&context);
    984   socket_stream->SetClientSocketFactory(&mock_socket_factory);
    985   delegate->set_socket_stream(socket_stream);
    986   // The delegate pointer will become invalid during the test. Set it to NULL to
    987   // avoid holding a dangling pointer.
    988   delegate = NULL;
    989 
    990   socket_stream->Connect();
    991 
    992   EXPECT_EQ(OK, test_callback.WaitForResult());
    993 }
    994 
    995 TEST_F(SocketStreamTest, NullContextSocketStreamShouldNotCrash) {
    996   TestCompletionCallback test_callback;
    997 
    998   scoped_ptr<SocketStreamEventRecorder> delegate(
    999       new SocketStreamEventRecorder(test_callback.callback()));
   1000   TestURLRequestContext context;
   1001   scoped_refptr<SocketStream> socket_stream(
   1002       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
   1003   delegate->SetOnStartOpenConnection(base::Bind(
   1004       &SocketStreamTest::DoIOPending, base::Unretained(this)));
   1005   delegate->SetOnConnected(base::Bind(
   1006       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
   1007   delegate->SetOnReceivedData(base::Bind(
   1008       &SocketStreamTest::DoCloseFlushPendingWriteTestWithSetContextNull,
   1009       base::Unretained(this)));
   1010 
   1011   socket_stream->set_context(&context);
   1012 
   1013   MockWrite data_writes[] = {
   1014     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
   1015   };
   1016   MockRead data_reads[] = {
   1017     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
   1018   };
   1019   AddWebSocketMessage("message1");
   1020   AddWebSocketMessage("message2");
   1021 
   1022   DelayedSocketData data_provider(
   1023       1, data_reads, arraysize(data_reads),
   1024       data_writes, arraysize(data_writes));
   1025 
   1026   MockClientSocketFactory* mock_socket_factory = GetMockClientSocketFactory();
   1027   mock_socket_factory->AddSocketDataProvider(&data_provider);
   1028   socket_stream->SetClientSocketFactory(mock_socket_factory);
   1029 
   1030   socket_stream->Connect();
   1031   io_test_callback_.WaitForResult();
   1032   delegate->CompleteConnection(OK);
   1033   EXPECT_EQ(OK, test_callback.WaitForResult());
   1034 
   1035   EXPECT_TRUE(data_provider.at_read_eof());
   1036   EXPECT_TRUE(data_provider.at_write_eof());
   1037 
   1038   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   1039   ASSERT_EQ(5U, events.size());
   1040 
   1041   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
   1042             events[0].event_type);
   1043   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   1044   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
   1045   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
   1046   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[4].event_type);
   1047 }
   1048 
   1049 }  // namespace net
   1050