Home | History | Annotate | Download | only in websockets 
      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 "net/websockets/websocket_job.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/memory/ref_counted.h"
     14 #include "base/strings/string_split.h"
     15 #include "base/strings/string_util.h"
     16 #include "net/base/completion_callback.h"
     17 #include "net/base/net_errors.h"
     18 #include "net/base/test_completion_callback.h"
     19 #include "net/cookies/cookie_store.h"
     20 #include "net/cookies/cookie_store_test_helpers.h"
     21 #include "net/dns/mock_host_resolver.h"
     22 #include "net/http/http_transaction_factory.h"
     23 #include "net/http/transport_security_state.h"
     24 #include "net/proxy/proxy_service.h"
     25 #include "net/socket/next_proto.h"
     26 #include "net/socket/socket_test_util.h"
     27 #include "net/socket_stream/socket_stream.h"
     28 #include "net/spdy/spdy_session.h"
     29 #include "net/spdy/spdy_websocket_test_util.h"
     30 #include "net/ssl/ssl_config_service.h"
     31 #include "net/url_request/url_request_context.h"
     32 #include "net/websockets/websocket_throttle.h"
     33 #include "testing/gmock/include/gmock/gmock.h"
     34 #include "testing/gtest/include/gtest/gtest.h"
     35 #include "testing/platform_test.h"
     36 #include "url/gurl.h"
     37 
     38 namespace net {
     39 
     40 namespace {
     41 
     42 class MockSocketStream : public SocketStream {
     43  public:
     44   MockSocketStream(const GURL& url, SocketStream::Delegate* delegate,
     45                    URLRequestContext* context, CookieStore* cookie_store)
     46       : SocketStream(url, delegate, context, cookie_store) {}
     47 
     48   virtual void Connect() OVERRIDE {}
     49   virtual bool SendData(const char* data, int len) OVERRIDE {
     50     sent_data_ += std::string(data, len);
     51     return true;
     52   }
     53 
     54   virtual void Close() OVERRIDE {}
     55   virtual void RestartWithAuth(
     56       const AuthCredentials& credentials) OVERRIDE {
     57   }
     58 
     59   virtual void DetachDelegate() OVERRIDE {
     60     delegate_ = NULL;
     61   }
     62 
     63   const std::string& sent_data() const {
     64     return sent_data_;
     65   }
     66 
     67  protected:
     68   virtual ~MockSocketStream() {}
     69 
     70  private:
     71   std::string sent_data_;
     72 };
     73 
     74 class MockSocketStreamDelegate : public SocketStream::Delegate {
     75  public:
     76   MockSocketStreamDelegate()
     77       : amount_sent_(0), allow_all_cookies_(true) {}
     78   void set_allow_all_cookies(bool allow_all_cookies) {
     79     allow_all_cookies_ = allow_all_cookies;
     80   }
     81   virtual ~MockSocketStreamDelegate() {}
     82 
     83   void SetOnStartOpenConnection(const base::Closure& callback) {
     84     on_start_open_connection_ = callback;
     85   }
     86   void SetOnConnected(const base::Closure& callback) {
     87     on_connected_ = callback;
     88   }
     89   void SetOnSentData(const base::Closure& callback) {
     90     on_sent_data_ = callback;
     91   }
     92   void SetOnReceivedData(const base::Closure& callback) {
     93     on_received_data_ = callback;
     94   }
     95   void SetOnClose(const base::Closure& callback) {
     96     on_close_ = callback;
     97   }
     98 
     99   virtual int OnStartOpenConnection(
    100       SocketStream* socket,
    101       const CompletionCallback& callback) OVERRIDE {
    102     if (!on_start_open_connection_.is_null())
    103       on_start_open_connection_.Run();
    104     return OK;
    105   }
    106   virtual void OnConnected(SocketStream* socket,
    107                            int max_pending_send_allowed) OVERRIDE {
    108     if (!on_connected_.is_null())
    109       on_connected_.Run();
    110   }
    111   virtual void OnSentData(SocketStream* socket,
    112                           int amount_sent) OVERRIDE {
    113     amount_sent_ += amount_sent;
    114     if (!on_sent_data_.is_null())
    115       on_sent_data_.Run();
    116   }
    117   virtual void OnReceivedData(SocketStream* socket,
    118                               const char* data, int len) OVERRIDE {
    119     received_data_ += std::string(data, len);
    120     if (!on_received_data_.is_null())
    121       on_received_data_.Run();
    122   }
    123   virtual void OnClose(SocketStream* socket) OVERRIDE {
    124     if (!on_close_.is_null())
    125       on_close_.Run();
    126   }
    127   virtual bool CanGetCookies(SocketStream* socket,
    128                              const GURL& url) OVERRIDE {
    129     return allow_all_cookies_;
    130   }
    131   virtual bool CanSetCookie(SocketStream* request,
    132                             const GURL& url,
    133                             const std::string& cookie_line,
    134                             CookieOptions* options) OVERRIDE {
    135     return allow_all_cookies_;
    136   }
    137 
    138   size_t amount_sent() const { return amount_sent_; }
    139   const std::string& received_data() const { return received_data_; }
    140 
    141  private:
    142   int amount_sent_;
    143   bool allow_all_cookies_;
    144   std::string received_data_;
    145   base::Closure on_start_open_connection_;
    146   base::Closure on_connected_;
    147   base::Closure on_sent_data_;
    148   base::Closure on_received_data_;
    149   base::Closure on_close_;
    150 };
    151 
    152 class MockCookieStore : public CookieStore {
    153  public:
    154   struct Entry {
    155     GURL url;
    156     std::string cookie_line;
    157     CookieOptions options;
    158   };
    159 
    160   MockCookieStore() {}
    161 
    162   bool SetCookieWithOptions(const GURL& url,
    163                             const std::string& cookie_line,
    164                             const CookieOptions& options) {
    165     Entry entry;
    166     entry.url = url;
    167     entry.cookie_line = cookie_line;
    168     entry.options = options;
    169     entries_.push_back(entry);
    170     return true;
    171   }
    172 
    173   std::string GetCookiesWithOptions(const GURL& url,
    174                                     const CookieOptions& options) {
    175     std::string result;
    176     for (size_t i = 0; i < entries_.size(); i++) {
    177       Entry& entry = entries_[i];
    178       if (url == entry.url) {
    179         if (!result.empty()) {
    180           result += "; ";
    181         }
    182         result += entry.cookie_line;
    183       }
    184     }
    185     return result;
    186   }
    187 
    188   // CookieStore:
    189   virtual void SetCookieWithOptionsAsync(
    190       const GURL& url,
    191       const std::string& cookie_line,
    192       const CookieOptions& options,
    193       const SetCookiesCallback& callback) OVERRIDE {
    194     bool result = SetCookieWithOptions(url, cookie_line, options);
    195     if (!callback.is_null())
    196       callback.Run(result);
    197   }
    198 
    199   virtual void GetCookiesWithOptionsAsync(
    200       const GURL& url,
    201       const CookieOptions& options,
    202       const GetCookiesCallback& callback) OVERRIDE {
    203     if (!callback.is_null())
    204       callback.Run(GetCookiesWithOptions(url, options));
    205   }
    206 
    207   virtual void GetAllCookiesForURLAsync(
    208       const GURL& url,
    209       const GetCookieListCallback& callback) OVERRIDE {
    210     ADD_FAILURE();
    211   }
    212 
    213   virtual void DeleteCookieAsync(const GURL& url,
    214                                  const std::string& cookie_name,
    215                                  const base::Closure& callback) OVERRIDE {
    216     ADD_FAILURE();
    217   }
    218 
    219   virtual void DeleteAllCreatedBetweenAsync(
    220       const base::Time& delete_begin,
    221       const base::Time& delete_end,
    222       const DeleteCallback& callback) OVERRIDE {
    223     ADD_FAILURE();
    224   }
    225 
    226   virtual void DeleteAllCreatedBetweenForHostAsync(
    227       const base::Time delete_begin,
    228       const base::Time delete_end,
    229       const GURL& url,
    230       const DeleteCallback& callback) OVERRIDE {
    231     ADD_FAILURE();
    232   }
    233 
    234   virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE {
    235     ADD_FAILURE();
    236   }
    237 
    238   virtual CookieMonster* GetCookieMonster() OVERRIDE { return NULL; }
    239 
    240   const std::vector<Entry>& entries() const { return entries_; }
    241 
    242  private:
    243   friend class base::RefCountedThreadSafe<MockCookieStore>;
    244   virtual ~MockCookieStore() {}
    245 
    246   std::vector<Entry> entries_;
    247 };
    248 
    249 class MockSSLConfigService : public SSLConfigService {
    250  public:
    251   virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {}
    252 
    253  protected:
    254   virtual ~MockSSLConfigService() {}
    255 };
    256 
    257 class MockURLRequestContext : public URLRequestContext {
    258  public:
    259   explicit MockURLRequestContext(CookieStore* cookie_store)
    260       : transport_security_state_() {
    261     set_cookie_store(cookie_store);
    262     set_transport_security_state(&transport_security_state_);
    263     base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
    264     bool include_subdomains = false;
    265     transport_security_state_.AddHSTS("upgrademe.com", expiry,
    266                                       include_subdomains);
    267   }
    268 
    269   virtual ~MockURLRequestContext() {
    270     AssertNoURLRequests();
    271   }
    272 
    273  private:
    274   TransportSecurityState transport_security_state_;
    275 };
    276 
    277 class MockHttpTransactionFactory : public HttpTransactionFactory {
    278  public:
    279   MockHttpTransactionFactory(NextProto next_proto,
    280                              OrderedSocketData* data,
    281                              bool enable_websocket_over_spdy) {
    282     data_ = data;
    283     MockConnect connect_data(SYNCHRONOUS, OK);
    284     data_->set_connect_data(connect_data);
    285     session_deps_.reset(new SpdySessionDependencies(next_proto));
    286     session_deps_->enable_websocket_over_spdy = enable_websocket_over_spdy;
    287     session_deps_->socket_factory->AddSocketDataProvider(data_);
    288     http_session_ =
    289         SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
    290     host_port_pair_.set_host("example.com");
    291     host_port_pair_.set_port(80);
    292     spdy_session_key_ = SpdySessionKey(host_port_pair_,
    293                                             ProxyServer::Direct(),
    294                                             PRIVACY_MODE_DISABLED);
    295     session_ = CreateInsecureSpdySession(
    296         http_session_, spdy_session_key_, BoundNetLog());
    297   }
    298 
    299   virtual int CreateTransaction(
    300       RequestPriority priority,
    301       scoped_ptr<HttpTransaction>* trans) OVERRIDE {
    302     NOTREACHED();
    303     return ERR_UNEXPECTED;
    304   }
    305 
    306   virtual HttpCache* GetCache() OVERRIDE {
    307     NOTREACHED();
    308     return NULL;
    309   }
    310 
    311   virtual HttpNetworkSession* GetSession() OVERRIDE {
    312     return http_session_.get();
    313   }
    314 
    315  private:
    316   OrderedSocketData* data_;
    317   scoped_ptr<SpdySessionDependencies> session_deps_;
    318   scoped_refptr<HttpNetworkSession> http_session_;
    319   base::WeakPtr<SpdySession> session_;
    320   HostPortPair host_port_pair_;
    321   SpdySessionKey spdy_session_key_;
    322 };
    323 
    324 class DeletingSocketStreamDelegate : public SocketStream::Delegate {
    325  public:
    326   DeletingSocketStreamDelegate()
    327       : delete_next_(false) {}
    328 
    329   // Since this class needs to be able to delete |job_|, it must be the only
    330   // reference holder (except for temporary references). Provide access to the
    331   // pointer for tests to use.
    332   WebSocketJob* job() { return job_.get(); }
    333 
    334   void set_job(WebSocketJob* job) { job_ = job; }
    335 
    336   // After calling this, the next call to a method on this delegate will delete
    337   // the WebSocketJob object.
    338   void set_delete_next(bool delete_next) { delete_next_ = delete_next; }
    339 
    340   void DeleteJobMaybe() {
    341     if (delete_next_) {
    342       job_->DetachContext();
    343       job_->DetachDelegate();
    344       job_ = NULL;
    345     }
    346   }
    347 
    348   // SocketStream::Delegate implementation
    349 
    350   // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost
    351 
    352   virtual void OnConnected(SocketStream* socket,
    353                            int max_pending_send_allowed) OVERRIDE {
    354     DeleteJobMaybe();
    355   }
    356 
    357   virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
    358     DeleteJobMaybe();
    359   }
    360 
    361   virtual void OnReceivedData(SocketStream* socket,
    362                               const char* data,
    363                               int len) OVERRIDE {
    364     DeleteJobMaybe();
    365   }
    366 
    367   virtual void OnClose(SocketStream* socket) OVERRIDE { DeleteJobMaybe(); }
    368 
    369   virtual void OnAuthRequired(SocketStream* socket,
    370                               AuthChallengeInfo* auth_info) OVERRIDE {
    371     DeleteJobMaybe();
    372   }
    373 
    374   virtual void OnSSLCertificateError(SocketStream* socket,
    375                                      const SSLInfo& ssl_info,
    376                                      bool fatal) OVERRIDE {
    377     DeleteJobMaybe();
    378   }
    379 
    380   virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
    381     DeleteJobMaybe();
    382   }
    383 
    384   // CanGetCookies() and CanSetCookies() do not appear to be able to delete the
    385   // WebSocketJob object.
    386 
    387  private:
    388   scoped_refptr<WebSocketJob> job_;
    389   bool delete_next_;
    390 };
    391 
    392 }  // namespace
    393 
    394 class WebSocketJobTest : public PlatformTest,
    395                          public ::testing::WithParamInterface<NextProto> {
    396  public:
    397   WebSocketJobTest()
    398       : spdy_util_(GetParam()),
    399         enable_websocket_over_spdy_(false) {}
    400 
    401   virtual void SetUp() OVERRIDE {
    402     stream_type_ = STREAM_INVALID;
    403     cookie_store_ = new MockCookieStore;
    404     context_.reset(new MockURLRequestContext(cookie_store_.get()));
    405   }
    406   virtual void TearDown() OVERRIDE {
    407     cookie_store_ = NULL;
    408     context_.reset();
    409     websocket_ = NULL;
    410     socket_ = NULL;
    411   }
    412   void DoSendRequest() {
    413     EXPECT_TRUE(websocket_->SendData(kHandshakeRequestWithoutCookie,
    414                                      kHandshakeRequestWithoutCookieLength));
    415   }
    416   void DoSendData() {
    417     if (received_data().size() == kHandshakeResponseWithoutCookieLength)
    418       websocket_->SendData(kDataHello, kDataHelloLength);
    419   }
    420   void DoSync() {
    421     sync_test_callback_.callback().Run(OK);
    422   }
    423   int WaitForResult() {
    424     return sync_test_callback_.WaitForResult();
    425   }
    426 
    427  protected:
    428   enum StreamType {
    429     STREAM_INVALID,
    430     STREAM_MOCK_SOCKET,
    431     STREAM_SOCKET,
    432     STREAM_SPDY_WEBSOCKET,
    433   };
    434   enum ThrottlingOption {
    435     THROTTLING_OFF,
    436     THROTTLING_ON,
    437   };
    438   enum SpdyOption {
    439     SPDY_OFF,
    440     SPDY_ON,
    441   };
    442   void InitWebSocketJob(const GURL& url,
    443                         MockSocketStreamDelegate* delegate,
    444                         StreamType stream_type) {
    445     DCHECK_NE(STREAM_INVALID, stream_type);
    446     stream_type_ = stream_type;
    447     websocket_ = new WebSocketJob(delegate);
    448 
    449     if (stream_type == STREAM_MOCK_SOCKET)
    450       socket_ = new MockSocketStream(url, websocket_.get(), context_.get(),
    451                                      NULL);
    452 
    453     if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) {
    454       if (stream_type == STREAM_SPDY_WEBSOCKET) {
    455         http_factory_.reset(new MockHttpTransactionFactory(
    456             GetParam(), data_.get(), enable_websocket_over_spdy_));
    457         context_->set_http_transaction_factory(http_factory_.get());
    458       }
    459 
    460       ssl_config_service_ = new MockSSLConfigService();
    461       context_->set_ssl_config_service(ssl_config_service_.get());
    462       proxy_service_.reset(ProxyService::CreateDirect());
    463       context_->set_proxy_service(proxy_service_.get());
    464       host_resolver_.reset(new MockHostResolver);
    465       context_->set_host_resolver(host_resolver_.get());
    466 
    467       socket_ = new SocketStream(url, websocket_.get(), context_.get(), NULL);
    468       socket_factory_.reset(new MockClientSocketFactory);
    469       DCHECK(data_.get());
    470       socket_factory_->AddSocketDataProvider(data_.get());
    471       socket_->SetClientSocketFactory(socket_factory_.get());
    472     }
    473 
    474     websocket_->InitSocketStream(socket_.get());
    475     // MockHostResolver resolves all hosts to 127.0.0.1; however, when we create
    476     // a WebSocketJob purely to block another one in a throttling test, we don't
    477     // perform a real connect. In that case, the following address is used
    478     // instead.
    479     IPAddressNumber ip;
    480     ParseIPLiteralToNumber("127.0.0.1", &ip);
    481     websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 80);
    482   }
    483   void SkipToConnecting() {
    484     websocket_->state_ = WebSocketJob::CONNECTING;
    485     ASSERT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get()));
    486   }
    487   WebSocketJob::State GetWebSocketJobState() {
    488     return websocket_->state_;
    489   }
    490   void CloseWebSocketJob() {
    491     if (websocket_->socket_.get()) {
    492       websocket_->socket_->DetachDelegate();
    493       WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get());
    494     }
    495     websocket_->state_ = WebSocketJob::CLOSED;
    496     websocket_->delegate_ = NULL;
    497     websocket_->socket_ = NULL;
    498   }
    499   SocketStream* GetSocket(SocketStreamJob* job) {
    500     return job->socket_.get();
    501   }
    502   const std::string& sent_data() const {
    503     DCHECK_EQ(STREAM_MOCK_SOCKET, stream_type_);
    504     MockSocketStream* socket =
    505         static_cast<MockSocketStream*>(socket_.get());
    506     DCHECK(socket);
    507     return socket->sent_data();
    508   }
    509   const std::string& received_data() const {
    510     DCHECK_NE(STREAM_INVALID, stream_type_);
    511     MockSocketStreamDelegate* delegate =
    512         static_cast<MockSocketStreamDelegate*>(websocket_->delegate_);
    513     DCHECK(delegate);
    514     return delegate->received_data();
    515   }
    516 
    517   void TestSimpleHandshake();
    518   void TestSlowHandshake();
    519   void TestHandshakeWithCookie();
    520   void TestHandshakeWithCookieButNotAllowed();
    521   void TestHSTSUpgrade();
    522   void TestInvalidSendData();
    523   void TestConnectByWebSocket(ThrottlingOption throttling);
    524   void TestConnectBySpdy(SpdyOption spdy, ThrottlingOption throttling);
    525   void TestThrottlingLimit();
    526 
    527   SpdyWebSocketTestUtil spdy_util_;
    528   StreamType stream_type_;
    529   scoped_refptr<MockCookieStore> cookie_store_;
    530   scoped_ptr<MockURLRequestContext> context_;
    531   scoped_refptr<WebSocketJob> websocket_;
    532   scoped_refptr<SocketStream> socket_;
    533   scoped_ptr<MockClientSocketFactory> socket_factory_;
    534   scoped_ptr<OrderedSocketData> data_;
    535   TestCompletionCallback sync_test_callback_;
    536   scoped_refptr<MockSSLConfigService> ssl_config_service_;
    537   scoped_ptr<ProxyService> proxy_service_;
    538   scoped_ptr<MockHostResolver> host_resolver_;
    539   scoped_ptr<MockHttpTransactionFactory> http_factory_;
    540 
    541   // Must be set before call to enable_websocket_over_spdy, defaults to false.
    542   bool enable_websocket_over_spdy_;
    543 
    544   static const char kHandshakeRequestWithoutCookie[];
    545   static const char kHandshakeRequestWithCookie[];
    546   static const char kHandshakeRequestWithFilteredCookie[];
    547   static const char kHandshakeResponseWithoutCookie[];
    548   static const char kHandshakeResponseWithCookie[];
    549   static const char kDataHello[];
    550   static const char kDataWorld[];
    551   static const char* const kHandshakeRequestForSpdy[];
    552   static const char* const kHandshakeResponseForSpdy[];
    553   static const size_t kHandshakeRequestWithoutCookieLength;
    554   static const size_t kHandshakeRequestWithCookieLength;
    555   static const size_t kHandshakeRequestWithFilteredCookieLength;
    556   static const size_t kHandshakeResponseWithoutCookieLength;
    557   static const size_t kHandshakeResponseWithCookieLength;
    558   static const size_t kDataHelloLength;
    559   static const size_t kDataWorldLength;
    560 };
    561 
    562 // Tests using this fixture verify that the WebSocketJob can handle being
    563 // deleted while calling back to the delegate correctly. These tests need to be
    564 // run under AddressSanitizer or other systems for detecting use-after-free
    565 // errors in order to find problems.
    566 class WebSocketJobDeleteTest : public ::testing::Test {
    567  protected:
    568   WebSocketJobDeleteTest()
    569       : delegate_(new DeletingSocketStreamDelegate),
    570         cookie_store_(new MockCookieStore),
    571         context_(new MockURLRequestContext(cookie_store_.get())) {
    572     WebSocketJob* websocket = new WebSocketJob(delegate_.get());
    573     delegate_->set_job(websocket);
    574 
    575     socket_ = new MockSocketStream(
    576         GURL("ws://127.0.0.1/"), websocket, context_.get(), NULL);
    577 
    578     websocket->InitSocketStream(socket_.get());
    579   }
    580 
    581   void SetDeleteNext() { return delegate_->set_delete_next(true); }
    582   WebSocketJob* job() { return delegate_->job(); }
    583 
    584   scoped_ptr<DeletingSocketStreamDelegate> delegate_;
    585   scoped_refptr<MockCookieStore> cookie_store_;
    586   scoped_ptr<MockURLRequestContext> context_;
    587   scoped_refptr<SocketStream> socket_;
    588 };
    589 
    590 const char WebSocketJobTest::kHandshakeRequestWithoutCookie[] =
    591     "GET /demo HTTP/1.1\r\n"
    592     "Host: example.com\r\n"
    593     "Upgrade: WebSocket\r\n"
    594     "Connection: Upgrade\r\n"
    595     "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
    596     "Origin: http://example.com\r\n"
    597     "Sec-WebSocket-Protocol: sample\r\n"
    598     "Sec-WebSocket-Version: 13\r\n"
    599     "\r\n";
    600 
    601 const char WebSocketJobTest::kHandshakeRequestWithCookie[] =
    602     "GET /demo HTTP/1.1\r\n"
    603     "Host: example.com\r\n"
    604     "Upgrade: WebSocket\r\n"
    605     "Connection: Upgrade\r\n"
    606     "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
    607     "Origin: http://example.com\r\n"
    608     "Sec-WebSocket-Protocol: sample\r\n"
    609     "Sec-WebSocket-Version: 13\r\n"
    610     "Cookie: WK-test=1\r\n"
    611     "\r\n";
    612 
    613 const char WebSocketJobTest::kHandshakeRequestWithFilteredCookie[] =
    614     "GET /demo HTTP/1.1\r\n"
    615     "Host: example.com\r\n"
    616     "Upgrade: WebSocket\r\n"
    617     "Connection: Upgrade\r\n"
    618     "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
    619     "Origin: http://example.com\r\n"
    620     "Sec-WebSocket-Protocol: sample\r\n"
    621     "Sec-WebSocket-Version: 13\r\n"
    622     "Cookie: CR-test=1; CR-test-httponly=1\r\n"
    623     "\r\n";
    624 
    625 const char WebSocketJobTest::kHandshakeResponseWithoutCookie[] =
    626     "HTTP/1.1 101 Switching Protocols\r\n"
    627     "Upgrade: websocket\r\n"
    628     "Connection: Upgrade\r\n"
    629     "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
    630     "Sec-WebSocket-Protocol: sample\r\n"
    631     "\r\n";
    632 
    633 const char WebSocketJobTest::kHandshakeResponseWithCookie[] =
    634     "HTTP/1.1 101 Switching Protocols\r\n"
    635     "Upgrade: websocket\r\n"
    636     "Connection: Upgrade\r\n"
    637     "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
    638     "Sec-WebSocket-Protocol: sample\r\n"
    639     "Set-Cookie: CR-set-test=1\r\n"
    640     "\r\n";
    641 
    642 const char WebSocketJobTest::kDataHello[] = "Hello, ";
    643 
    644 const char WebSocketJobTest::kDataWorld[] = "World!\n";
    645 
    646 const size_t WebSocketJobTest::kHandshakeRequestWithoutCookieLength =
    647     arraysize(kHandshakeRequestWithoutCookie) - 1;
    648 const size_t WebSocketJobTest::kHandshakeRequestWithCookieLength =
    649     arraysize(kHandshakeRequestWithCookie) - 1;
    650 const size_t WebSocketJobTest::kHandshakeRequestWithFilteredCookieLength =
    651     arraysize(kHandshakeRequestWithFilteredCookie) - 1;
    652 const size_t WebSocketJobTest::kHandshakeResponseWithoutCookieLength =
    653     arraysize(kHandshakeResponseWithoutCookie) - 1;
    654 const size_t WebSocketJobTest::kHandshakeResponseWithCookieLength =
    655     arraysize(kHandshakeResponseWithCookie) - 1;
    656 const size_t WebSocketJobTest::kDataHelloLength =
    657     arraysize(kDataHello) - 1;
    658 const size_t WebSocketJobTest::kDataWorldLength =
    659     arraysize(kDataWorld) - 1;
    660 
    661 void WebSocketJobTest::TestSimpleHandshake() {
    662   GURL url("ws://example.com/demo");
    663   MockSocketStreamDelegate delegate;
    664   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    665   SkipToConnecting();
    666 
    667   DoSendRequest();
    668   base::MessageLoop::current()->RunUntilIdle();
    669   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
    670   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    671   websocket_->OnSentData(socket_.get(),
    672                          kHandshakeRequestWithoutCookieLength);
    673   EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent());
    674 
    675   websocket_->OnReceivedData(socket_.get(),
    676                              kHandshakeResponseWithoutCookie,
    677                              kHandshakeResponseWithoutCookieLength);
    678   base::MessageLoop::current()->RunUntilIdle();
    679   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
    680   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
    681   CloseWebSocketJob();
    682 }
    683 
    684 void WebSocketJobTest::TestSlowHandshake() {
    685   GURL url("ws://example.com/demo");
    686   MockSocketStreamDelegate delegate;
    687   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    688   SkipToConnecting();
    689 
    690   DoSendRequest();
    691   // We assume request is sent in one data chunk (from WebKit)
    692   // We don't support streaming request.
    693   base::MessageLoop::current()->RunUntilIdle();
    694   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
    695   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    696   websocket_->OnSentData(socket_.get(),
    697                          kHandshakeRequestWithoutCookieLength);
    698   EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent());
    699 
    700   std::vector<std::string> lines;
    701   base::SplitString(kHandshakeResponseWithoutCookie, '\n', &lines);
    702   for (size_t i = 0; i < lines.size() - 2; i++) {
    703     std::string line = lines[i] + "\r\n";
    704     SCOPED_TRACE("Line: " + line);
    705     websocket_->OnReceivedData(socket_.get(), line.c_str(), line.size());
    706     base::MessageLoop::current()->RunUntilIdle();
    707     EXPECT_TRUE(delegate.received_data().empty());
    708     EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    709   }
    710   websocket_->OnReceivedData(socket_.get(), "\r\n", 2);
    711   base::MessageLoop::current()->RunUntilIdle();
    712   EXPECT_FALSE(delegate.received_data().empty());
    713   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
    714   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
    715   CloseWebSocketJob();
    716 }
    717 
    718 INSTANTIATE_TEST_CASE_P(
    719     NextProto,
    720     WebSocketJobTest,
    721     testing::Values(kProtoDeprecatedSPDY2,
    722                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
    723 
    724 TEST_P(WebSocketJobTest, DelayedCookies) {
    725   enable_websocket_over_spdy_ = true;
    726   GURL url("ws://example.com/demo");
    727   GURL cookieUrl("http://example.com/demo");
    728   CookieOptions cookie_options;
    729   scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster();
    730   context_->set_cookie_store(cookie_store.get());
    731   cookie_store->SetCookieWithOptionsAsync(cookieUrl,
    732                                           "CR-test=1",
    733                                           cookie_options,
    734                                           CookieMonster::SetCookiesCallback());
    735   cookie_options.set_include_httponly();
    736   cookie_store->SetCookieWithOptionsAsync(
    737       cookieUrl, "CR-test-httponly=1", cookie_options,
    738       CookieMonster::SetCookiesCallback());
    739 
    740   MockSocketStreamDelegate delegate;
    741   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    742   SkipToConnecting();
    743 
    744   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
    745                                    kHandshakeRequestWithCookieLength);
    746   EXPECT_TRUE(sent);
    747   base::MessageLoop::current()->RunUntilIdle();
    748   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
    749   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    750   websocket_->OnSentData(socket_.get(),
    751                          kHandshakeRequestWithFilteredCookieLength);
    752   EXPECT_EQ(kHandshakeRequestWithCookieLength,
    753             delegate.amount_sent());
    754 
    755   websocket_->OnReceivedData(socket_.get(),
    756                              kHandshakeResponseWithCookie,
    757                              kHandshakeResponseWithCookieLength);
    758   base::MessageLoop::current()->RunUntilIdle();
    759   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
    760   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
    761 
    762   CloseWebSocketJob();
    763 }
    764 
    765 void WebSocketJobTest::TestHandshakeWithCookie() {
    766   GURL url("ws://example.com/demo");
    767   GURL cookieUrl("http://example.com/demo");
    768   CookieOptions cookie_options;
    769   cookie_store_->SetCookieWithOptions(
    770       cookieUrl, "CR-test=1", cookie_options);
    771   cookie_options.set_include_httponly();
    772   cookie_store_->SetCookieWithOptions(
    773       cookieUrl, "CR-test-httponly=1", cookie_options);
    774 
    775   MockSocketStreamDelegate delegate;
    776   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    777   SkipToConnecting();
    778 
    779   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
    780                                    kHandshakeRequestWithCookieLength);
    781   EXPECT_TRUE(sent);
    782   base::MessageLoop::current()->RunUntilIdle();
    783   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
    784   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    785   websocket_->OnSentData(socket_.get(),
    786                          kHandshakeRequestWithFilteredCookieLength);
    787   EXPECT_EQ(kHandshakeRequestWithCookieLength,
    788             delegate.amount_sent());
    789 
    790   websocket_->OnReceivedData(socket_.get(),
    791                              kHandshakeResponseWithCookie,
    792                              kHandshakeResponseWithCookieLength);
    793   base::MessageLoop::current()->RunUntilIdle();
    794   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
    795   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
    796 
    797   EXPECT_EQ(3U, cookie_store_->entries().size());
    798   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
    799   EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line);
    800   EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url);
    801   EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line);
    802   EXPECT_EQ(cookieUrl, cookie_store_->entries()[2].url);
    803   EXPECT_EQ("CR-set-test=1", cookie_store_->entries()[2].cookie_line);
    804 
    805   CloseWebSocketJob();
    806 }
    807 
    808 void WebSocketJobTest::TestHandshakeWithCookieButNotAllowed() {
    809   GURL url("ws://example.com/demo");
    810   GURL cookieUrl("http://example.com/demo");
    811   CookieOptions cookie_options;
    812   cookie_store_->SetCookieWithOptions(
    813       cookieUrl, "CR-test=1", cookie_options);
    814   cookie_options.set_include_httponly();
    815   cookie_store_->SetCookieWithOptions(
    816       cookieUrl, "CR-test-httponly=1", cookie_options);
    817 
    818   MockSocketStreamDelegate delegate;
    819   delegate.set_allow_all_cookies(false);
    820   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    821   SkipToConnecting();
    822 
    823   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
    824                                    kHandshakeRequestWithCookieLength);
    825   EXPECT_TRUE(sent);
    826   base::MessageLoop::current()->RunUntilIdle();
    827   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
    828   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    829   websocket_->OnSentData(socket_.get(), kHandshakeRequestWithoutCookieLength);
    830   EXPECT_EQ(kHandshakeRequestWithCookieLength, delegate.amount_sent());
    831 
    832   websocket_->OnReceivedData(socket_.get(),
    833                              kHandshakeResponseWithCookie,
    834                              kHandshakeResponseWithCookieLength);
    835   base::MessageLoop::current()->RunUntilIdle();
    836   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
    837   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
    838 
    839   EXPECT_EQ(2U, cookie_store_->entries().size());
    840   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
    841   EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line);
    842   EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url);
    843   EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line);
    844 
    845   CloseWebSocketJob();
    846 }
    847 
    848 void WebSocketJobTest::TestHSTSUpgrade() {
    849   GURL url("ws://upgrademe.com/");
    850   MockSocketStreamDelegate delegate;
    851   scoped_refptr<SocketStreamJob> job =
    852       SocketStreamJob::CreateSocketStreamJob(
    853           url, &delegate, context_->transport_security_state(),
    854           context_->ssl_config_service(), NULL, NULL);
    855   EXPECT_TRUE(GetSocket(job.get())->is_secure());
    856   job->DetachDelegate();
    857 
    858   url = GURL("ws://donotupgrademe.com/");
    859   job = SocketStreamJob::CreateSocketStreamJob(
    860       url, &delegate, context_->transport_security_state(),
    861       context_->ssl_config_service(), NULL, NULL);
    862   EXPECT_FALSE(GetSocket(job.get())->is_secure());
    863   job->DetachDelegate();
    864 }
    865 
    866 void WebSocketJobTest::TestInvalidSendData() {
    867   GURL url("ws://example.com/demo");
    868   MockSocketStreamDelegate delegate;
    869   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
    870   SkipToConnecting();
    871 
    872   DoSendRequest();
    873   // We assume request is sent in one data chunk (from WebKit)
    874   // We don't support streaming request.
    875   base::MessageLoop::current()->RunUntilIdle();
    876   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
    877   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    878   websocket_->OnSentData(socket_.get(),
    879                          kHandshakeRequestWithoutCookieLength);
    880   EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent());
    881 
    882   // We could not send any data until connection is established.
    883   bool sent = websocket_->SendData(kHandshakeRequestWithoutCookie,
    884                                    kHandshakeRequestWithoutCookieLength);
    885   EXPECT_FALSE(sent);
    886   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
    887   CloseWebSocketJob();
    888 }
    889 
    890 // Following tests verify cooperation between WebSocketJob and SocketStream.
    891 // Other former tests use MockSocketStream as SocketStream, so we could not
    892 // check SocketStream behavior.
    893 // OrderedSocketData provide socket level verifiation by checking out-going
    894 // packets in comparison with the MockWrite array and emulating in-coming
    895 // packets with MockRead array.
    896 
    897 void WebSocketJobTest::TestConnectByWebSocket(
    898     ThrottlingOption throttling) {
    899   // This is a test for verifying cooperation between WebSocketJob and
    900   // SocketStream. If |throttling| was |THROTTLING_OFF|, it test basic
    901   // situation. If |throttling| was |THROTTLING_ON|, throttling limits the
    902   // latter connection.
    903   MockWrite writes[] = {
    904     MockWrite(ASYNC,
    905               kHandshakeRequestWithoutCookie,
    906               kHandshakeRequestWithoutCookieLength,
    907               1),
    908     MockWrite(ASYNC,
    909               kDataHello,
    910               kDataHelloLength,
    911               3)
    912   };
    913   MockRead reads[] = {
    914     MockRead(ASYNC,
    915              kHandshakeResponseWithoutCookie,
    916              kHandshakeResponseWithoutCookieLength,
    917              2),
    918     MockRead(ASYNC,
    919              kDataWorld,
    920              kDataWorldLength,
    921              4),
    922     MockRead(SYNCHRONOUS, 0, 5)  // EOF
    923   };
    924   data_.reset(new OrderedSocketData(
    925       reads, arraysize(reads), writes, arraysize(writes)));
    926 
    927   GURL url("ws://example.com/demo");
    928   MockSocketStreamDelegate delegate;
    929   WebSocketJobTest* test = this;
    930   if (throttling == THROTTLING_ON)
    931     delegate.SetOnStartOpenConnection(
    932         base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
    933   delegate.SetOnConnected(
    934       base::Bind(&WebSocketJobTest::DoSendRequest,
    935                  base::Unretained(test)));
    936   delegate.SetOnReceivedData(
    937       base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
    938   delegate.SetOnClose(
    939       base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
    940   InitWebSocketJob(url, &delegate, STREAM_SOCKET);
    941 
    942   scoped_refptr<WebSocketJob> block_websocket;
    943   if (throttling == THROTTLING_ON) {
    944     // Create former WebSocket object which obstructs the latter one.
    945     block_websocket = new WebSocketJob(NULL);
    946     block_websocket->addresses_ = AddressList(websocket_->address_list());
    947     ASSERT_TRUE(
    948         WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get()));
    949   }
    950 
    951   websocket_->Connect();
    952 
    953   if (throttling == THROTTLING_ON) {
    954     EXPECT_EQ(OK, WaitForResult());
    955     EXPECT_TRUE(websocket_->IsWaiting());
    956 
    957     // Remove the former WebSocket object from throttling queue to unblock the
    958     // latter.
    959     block_websocket->state_ = WebSocketJob::CLOSED;
    960     WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
    961     block_websocket = NULL;
    962   }
    963 
    964   EXPECT_EQ(OK, WaitForResult());
    965   EXPECT_TRUE(data_->at_read_eof());
    966   EXPECT_TRUE(data_->at_write_eof());
    967   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
    968 }
    969 
    970 void WebSocketJobTest::TestConnectBySpdy(
    971     SpdyOption spdy, ThrottlingOption throttling) {
    972   // This is a test for verifying cooperation between WebSocketJob and
    973   // SocketStream in the situation we have SPDY session to the server. If
    974   // |throttling| was |THROTTLING_ON|, throttling limits the latter connection.
    975   // If you enabled spdy, you should specify |spdy| as |SPDY_ON|. Expected
    976   // results depend on its configuration.
    977   MockWrite writes_websocket[] = {
    978     MockWrite(ASYNC,
    979               kHandshakeRequestWithoutCookie,
    980               kHandshakeRequestWithoutCookieLength,
    981               1),
    982     MockWrite(ASYNC,
    983               kDataHello,
    984               kDataHelloLength,
    985               3)
    986   };
    987   MockRead reads_websocket[] = {
    988     MockRead(ASYNC,
    989              kHandshakeResponseWithoutCookie,
    990              kHandshakeResponseWithoutCookieLength,
    991              2),
    992     MockRead(ASYNC,
    993              kDataWorld,
    994              kDataWorldLength,
    995              4),
    996     MockRead(SYNCHRONOUS, 0, 5)  // EOF
    997   };
    998 
    999   scoped_ptr<SpdyHeaderBlock> request_headers(new SpdyHeaderBlock());
   1000   spdy_util_.SetHeader("path", "/demo", request_headers.get());
   1001   spdy_util_.SetHeader("version", "WebSocket/13", request_headers.get());
   1002   spdy_util_.SetHeader("scheme", "ws", request_headers.get());
   1003   spdy_util_.SetHeader("host", "example.com", request_headers.get());
   1004   spdy_util_.SetHeader("origin", "http://example.com", request_headers.get());
   1005   spdy_util_.SetHeader("sec-websocket-protocol", "sample",
   1006                        request_headers.get());
   1007 
   1008   scoped_ptr<SpdyHeaderBlock> response_headers(new SpdyHeaderBlock());
   1009   spdy_util_.SetHeader("status", "101 Switching Protocols",
   1010                        response_headers.get());
   1011   spdy_util_.SetHeader("sec-websocket-protocol", "sample",
   1012                        response_headers.get());
   1013 
   1014   const SpdyStreamId kStreamId = 1;
   1015   scoped_ptr<SpdyFrame> request_frame(
   1016       spdy_util_.ConstructSpdyWebSocketHandshakeRequestFrame(
   1017           request_headers.Pass(),
   1018           kStreamId,
   1019           MEDIUM));
   1020   scoped_ptr<SpdyFrame> response_frame(
   1021       spdy_util_.ConstructSpdyWebSocketHandshakeResponseFrame(
   1022           response_headers.Pass(),
   1023           kStreamId,
   1024           MEDIUM));
   1025   scoped_ptr<SpdyFrame> data_hello_frame(
   1026       spdy_util_.ConstructSpdyWebSocketDataFrame(
   1027           kDataHello,
   1028           kDataHelloLength,
   1029           kStreamId,
   1030           false));
   1031   scoped_ptr<SpdyFrame> data_world_frame(
   1032       spdy_util_.ConstructSpdyWebSocketDataFrame(
   1033           kDataWorld,
   1034           kDataWorldLength,
   1035           kStreamId,
   1036           false));
   1037   MockWrite writes_spdy[] = {
   1038     CreateMockWrite(*request_frame.get(), 1),
   1039     CreateMockWrite(*data_hello_frame.get(), 3),
   1040   };
   1041   MockRead reads_spdy[] = {
   1042     CreateMockRead(*response_frame.get(), 2),
   1043     CreateMockRead(*data_world_frame.get(), 4),
   1044     MockRead(SYNCHRONOUS, 0, 5)  // EOF
   1045   };
   1046 
   1047   if (spdy == SPDY_ON)
   1048     data_.reset(new OrderedSocketData(
   1049         reads_spdy, arraysize(reads_spdy),
   1050         writes_spdy, arraysize(writes_spdy)));
   1051   else
   1052     data_.reset(new OrderedSocketData(
   1053         reads_websocket, arraysize(reads_websocket),
   1054         writes_websocket, arraysize(writes_websocket)));
   1055 
   1056   GURL url("ws://example.com/demo");
   1057   MockSocketStreamDelegate delegate;
   1058   WebSocketJobTest* test = this;
   1059   if (throttling == THROTTLING_ON)
   1060     delegate.SetOnStartOpenConnection(
   1061         base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   1062   delegate.SetOnConnected(
   1063       base::Bind(&WebSocketJobTest::DoSendRequest,
   1064                  base::Unretained(test)));
   1065   delegate.SetOnReceivedData(
   1066       base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
   1067   delegate.SetOnClose(
   1068       base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   1069   InitWebSocketJob(url, &delegate, STREAM_SPDY_WEBSOCKET);
   1070 
   1071   scoped_refptr<WebSocketJob> block_websocket;
   1072   if (throttling == THROTTLING_ON) {
   1073     // Create former WebSocket object which obstructs the latter one.
   1074     block_websocket = new WebSocketJob(NULL);
   1075     block_websocket->addresses_ = AddressList(websocket_->address_list());
   1076     ASSERT_TRUE(
   1077         WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get()));
   1078   }
   1079 
   1080   websocket_->Connect();
   1081 
   1082   if (throttling == THROTTLING_ON) {
   1083     EXPECT_EQ(OK, WaitForResult());
   1084     EXPECT_TRUE(websocket_->IsWaiting());
   1085 
   1086     // Remove the former WebSocket object from throttling queue to unblock the
   1087     // latter.
   1088     block_websocket->state_ = WebSocketJob::CLOSED;
   1089     WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
   1090     block_websocket = NULL;
   1091   }
   1092 
   1093   EXPECT_EQ(OK, WaitForResult());
   1094   EXPECT_TRUE(data_->at_read_eof());
   1095   EXPECT_TRUE(data_->at_write_eof());
   1096   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
   1097 }
   1098 
   1099 void WebSocketJobTest::TestThrottlingLimit() {
   1100   std::vector<scoped_refptr<WebSocketJob> > jobs;
   1101   const int kMaxWebSocketJobsThrottled = 1024;
   1102   IPAddressNumber ip;
   1103   ParseIPLiteralToNumber("127.0.0.1", &ip);
   1104   for (int i = 0; i < kMaxWebSocketJobsThrottled + 1; ++i) {
   1105     scoped_refptr<WebSocketJob> job = new WebSocketJob(NULL);
   1106     job->addresses_ = AddressList(AddressList::CreateFromIPAddress(ip, 80));
   1107     if (i >= kMaxWebSocketJobsThrottled)
   1108       EXPECT_FALSE(WebSocketThrottle::GetInstance()->PutInQueue(job.get()));
   1109     else
   1110       EXPECT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(job.get()));
   1111     jobs.push_back(job);
   1112   }
   1113 
   1114   // Close the jobs in reverse order. Otherwise, We need to make them prepared
   1115   // for Wakeup call.
   1116   for (std::vector<scoped_refptr<WebSocketJob> >::reverse_iterator iter =
   1117            jobs.rbegin();
   1118        iter != jobs.rend();
   1119        ++iter) {
   1120     WebSocketJob* job = (*iter).get();
   1121     job->state_ = WebSocketJob::CLOSED;
   1122     WebSocketThrottle::GetInstance()->RemoveFromQueue(job);
   1123   }
   1124 }
   1125 
   1126 // Execute tests in both spdy-disabled mode and spdy-enabled mode.
   1127 TEST_P(WebSocketJobTest, SimpleHandshake) {
   1128   TestSimpleHandshake();
   1129 }
   1130 
   1131 TEST_P(WebSocketJobTest, SlowHandshake) {
   1132   TestSlowHandshake();
   1133 }
   1134 
   1135 TEST_P(WebSocketJobTest, HandshakeWithCookie) {
   1136   TestHandshakeWithCookie();
   1137 }
   1138 
   1139 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowed) {
   1140   TestHandshakeWithCookieButNotAllowed();
   1141 }
   1142 
   1143 TEST_P(WebSocketJobTest, HSTSUpgrade) {
   1144   TestHSTSUpgrade();
   1145 }
   1146 
   1147 TEST_P(WebSocketJobTest, InvalidSendData) {
   1148   TestInvalidSendData();
   1149 }
   1150 
   1151 TEST_P(WebSocketJobTest, SimpleHandshakeSpdyEnabled) {
   1152   enable_websocket_over_spdy_ = true;
   1153   TestSimpleHandshake();
   1154 }
   1155 
   1156 TEST_P(WebSocketJobTest, SlowHandshakeSpdyEnabled) {
   1157   enable_websocket_over_spdy_ = true;
   1158   TestSlowHandshake();
   1159 }
   1160 
   1161 TEST_P(WebSocketJobTest, HandshakeWithCookieSpdyEnabled) {
   1162   enable_websocket_over_spdy_ = true;
   1163   TestHandshakeWithCookie();
   1164 }
   1165 
   1166 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowedSpdyEnabled) {
   1167   enable_websocket_over_spdy_ = true;
   1168   TestHandshakeWithCookieButNotAllowed();
   1169 }
   1170 
   1171 TEST_P(WebSocketJobTest, HSTSUpgradeSpdyEnabled) {
   1172   enable_websocket_over_spdy_ = true;
   1173   TestHSTSUpgrade();
   1174 }
   1175 
   1176 TEST_P(WebSocketJobTest, InvalidSendDataSpdyEnabled) {
   1177   enable_websocket_over_spdy_ = true;
   1178   TestInvalidSendData();
   1179 }
   1180 
   1181 TEST_P(WebSocketJobTest, ConnectByWebSocket) {
   1182   enable_websocket_over_spdy_ = true;
   1183   TestConnectByWebSocket(THROTTLING_OFF);
   1184 }
   1185 
   1186 TEST_P(WebSocketJobTest, ConnectByWebSocketSpdyEnabled) {
   1187   enable_websocket_over_spdy_ = true;
   1188   TestConnectByWebSocket(THROTTLING_OFF);
   1189 }
   1190 
   1191 TEST_P(WebSocketJobTest, ConnectBySpdy) {
   1192   TestConnectBySpdy(SPDY_OFF, THROTTLING_OFF);
   1193 }
   1194 
   1195 TEST_P(WebSocketJobTest, ConnectBySpdySpdyEnabled) {
   1196   enable_websocket_over_spdy_ = true;
   1197   TestConnectBySpdy(SPDY_ON, THROTTLING_OFF);
   1198 }
   1199 
   1200 TEST_P(WebSocketJobTest, ThrottlingWebSocket) {
   1201   TestConnectByWebSocket(THROTTLING_ON);
   1202 }
   1203 
   1204 TEST_P(WebSocketJobTest, ThrottlingMaxNumberOfThrottledJobLimit) {
   1205   TestThrottlingLimit();
   1206 }
   1207 
   1208 TEST_P(WebSocketJobTest, ThrottlingWebSocketSpdyEnabled) {
   1209   enable_websocket_over_spdy_ = true;
   1210   TestConnectByWebSocket(THROTTLING_ON);
   1211 }
   1212 
   1213 TEST_P(WebSocketJobTest, ThrottlingSpdy) {
   1214   TestConnectBySpdy(SPDY_OFF, THROTTLING_ON);
   1215 }
   1216 
   1217 TEST_P(WebSocketJobTest, ThrottlingSpdySpdyEnabled) {
   1218   enable_websocket_over_spdy_ = true;
   1219   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
   1220 }
   1221 
   1222 TEST_F(WebSocketJobDeleteTest, OnClose) {
   1223   SetDeleteNext();
   1224   job()->OnClose(socket_.get());
   1225   // OnClose() sets WebSocketJob::_socket to NULL before we can detach it, so
   1226   // socket_->delegate is still set at this point. Clear it to avoid hitting
   1227   // DCHECK(!delegate_) in the SocketStream destructor. SocketStream::Finish()
   1228   // is the only caller of this method in real code, and it also sets delegate_
   1229   // to NULL.
   1230   socket_->DetachDelegate();
   1231   EXPECT_FALSE(job());
   1232 }
   1233 
   1234 TEST_F(WebSocketJobDeleteTest, OnAuthRequired) {
   1235   SetDeleteNext();
   1236   job()->OnAuthRequired(socket_.get(), NULL);
   1237   EXPECT_FALSE(job());
   1238 }
   1239 
   1240 TEST_F(WebSocketJobDeleteTest, OnSSLCertificateError) {
   1241   SSLInfo ssl_info;
   1242   SetDeleteNext();
   1243   job()->OnSSLCertificateError(socket_.get(), ssl_info, true);
   1244   EXPECT_FALSE(job());
   1245 }
   1246 
   1247 TEST_F(WebSocketJobDeleteTest, OnError) {
   1248   SetDeleteNext();
   1249   job()->OnError(socket_.get(), ERR_CONNECTION_RESET);
   1250   EXPECT_FALSE(job());
   1251 }
   1252 
   1253 TEST_F(WebSocketJobDeleteTest, OnSentSpdyHeaders) {
   1254   job()->Connect();
   1255   SetDeleteNext();
   1256   job()->OnSentSpdyHeaders();
   1257   EXPECT_FALSE(job());
   1258 }
   1259 
   1260 TEST_F(WebSocketJobDeleteTest, OnSentHandshakeRequest) {
   1261   static const char kMinimalRequest[] =
   1262       "GET /demo HTTP/1.1\r\n"
   1263       "Host: example.com\r\n"
   1264       "Upgrade: WebSocket\r\n"
   1265       "Connection: Upgrade\r\n"
   1266       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
   1267       "Origin: http://example.com\r\n"
   1268       "Sec-WebSocket-Version: 13\r\n"
   1269       "\r\n";
   1270   const size_t kMinimalRequestSize = arraysize(kMinimalRequest) - 1;
   1271   job()->Connect();
   1272   job()->SendData(kMinimalRequest, kMinimalRequestSize);
   1273   SetDeleteNext();
   1274   job()->OnSentData(socket_.get(), kMinimalRequestSize);
   1275   EXPECT_FALSE(job());
   1276 }
   1277 
   1278 TEST_F(WebSocketJobDeleteTest, NotifyHeadersComplete) {
   1279   static const char kMinimalResponse[] =
   1280       "HTTP/1.1 101 Switching Protocols\r\n"
   1281       "Upgrade: websocket\r\n"
   1282       "Connection: Upgrade\r\n"
   1283       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
   1284       "\r\n";
   1285   job()->Connect();
   1286   SetDeleteNext();
   1287   job()->OnReceivedData(
   1288       socket_.get(), kMinimalResponse, arraysize(kMinimalResponse) - 1);
   1289   EXPECT_FALSE(job());
   1290 }
   1291 
   1292 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
   1293 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
   1294 }  // namespace net
   1295