src/net/socket/transport_client_socket_pool_test_util.cc

   1 // Copyright 2014 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/transport_client_socket_pool_test_util.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "net/base/ip_endpoint.h"
  13 #include "net/base/load_timing_info.h"
  14 #include "net/base/load_timing_info_test_util.h"
  15 #include "net/base/net_util.h"
  16 #include "net/socket/client_socket_handle.h"
  17 #include "net/socket/ssl_client_socket.h"
  18 #include "net/udp/datagram_client_socket.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace net {
  22
  23 namespace {
  24
  25 IPAddressNumber ParseIP(const std::string& ip) {
  26   IPAddressNumber number;
  27   CHECK(ParseIPLiteralToNumber(ip, &number));
  28   return number;
  29 }
  30
  31 // A StreamSocket which connects synchronously and successfully.
  32 class MockConnectClientSocket : public StreamSocket {
  33  public:
  34   MockConnectClientSocket(const AddressList& addrlist, net::NetLog* net_log)
  35       : connected_(false),
  36         addrlist_(addrlist),
  37         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
  38         use_tcp_fastopen_(false) {}
  39
  40   // StreamSocket implementation.
  41   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
  42     connected_ = true;
  43     return OK;
  44   }
  45   virtual void Disconnect() OVERRIDE { connected_ = false; }
  46   virtual bool IsConnected() const OVERRIDE { return connected_; }
  47   virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; }
  48
  49   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
  50     *address = addrlist_.front();
  51     return OK;
  52   }
  53   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
  54     if (!connected_)
  55       return ERR_SOCKET_NOT_CONNECTED;
  56     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
  57       SetIPv4Address(address);
  58     else
  59       SetIPv6Address(address);
  60     return OK;
  61   }
  62   virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
  63
  64   virtual void SetSubresourceSpeculation() OVERRIDE {}
  65   virtual void SetOmniboxSpeculation() OVERRIDE {}
  66   virtual bool WasEverUsed() const OVERRIDE { return false; }
  67   virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
  68     use_tcp_fastopen_ = true;
  69   }
  70   virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
  71   virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
  72   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
  73     return kProtoUnknown;
  74   }
  75   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
  76
  77   // Socket implementation.
  78   virtual int Read(IOBuffer* buf,
  79                    int buf_len,
  80                    const CompletionCallback& callback) OVERRIDE {
  81     return ERR_FAILED;
  82   }
  83   virtual int Write(IOBuffer* buf,
  84                     int buf_len,
  85                     const CompletionCallback& callback) OVERRIDE {
  86     return ERR_FAILED;
  87   }
  88   virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
  89   virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
  90
  91  private:
  92   bool connected_;
  93   const AddressList addrlist_;
  94   BoundNetLog net_log_;
  95   bool use_tcp_fastopen_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(MockConnectClientSocket);
  98 };
  99
 100 class MockFailingClientSocket : public StreamSocket {
 101  public:
 102   MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log)
 103       : addrlist_(addrlist),
 104         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
 105         use_tcp_fastopen_(false) {}
 106
 107   // StreamSocket implementation.
 108   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
 109     return ERR_CONNECTION_FAILED;
 110   }
 111
 112   virtual void Disconnect() OVERRIDE {}
 113
 114   virtual bool IsConnected() const OVERRIDE { return false; }
 115   virtual bool IsConnectedAndIdle() const OVERRIDE { return false; }
 116   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
 117     return ERR_UNEXPECTED;
 118   }
 119   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
 120     return ERR_UNEXPECTED;
 121   }
 122   virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
 123
 124   virtual void SetSubresourceSpeculation() OVERRIDE {}
 125   virtual void SetOmniboxSpeculation() OVERRIDE {}
 126   virtual bool WasEverUsed() const OVERRIDE { return false; }
 127   virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
 128     use_tcp_fastopen_ = true;
 129   }
 130   virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
 131   virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
 132   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
 133     return kProtoUnknown;
 134   }
 135   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
 136
 137   // Socket implementation.
 138   virtual int Read(IOBuffer* buf,
 139                    int buf_len,
 140                    const CompletionCallback& callback) OVERRIDE {
 141     return ERR_FAILED;
 142   }
 143
 144   virtual int Write(IOBuffer* buf,
 145                     int buf_len,
 146                     const CompletionCallback& callback) OVERRIDE {
 147     return ERR_FAILED;
 148   }
 149   virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
 150   virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
 151
 152  private:
 153   const AddressList addrlist_;
 154   BoundNetLog net_log_;
 155   bool use_tcp_fastopen_;
 156
 157   DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket);
 158 };
 159
 160 class MockTriggerableClientSocket : public StreamSocket {
 161  public:
 162   // |should_connect| indicates whether the socket should successfully complete
 163   // or fail.
 164   MockTriggerableClientSocket(const AddressList& addrlist,
 165                               bool should_connect,
 166                               net::NetLog* net_log)
 167       : should_connect_(should_connect),
 168         is_connected_(false),
 169         addrlist_(addrlist),
 170         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
 171         use_tcp_fastopen_(false),
 172         weak_factory_(this) {}
 173
 174   // Call this method to get a closure which will trigger the connect callback
 175   // when called. The closure can be called even after the socket is deleted; it
 176   // will safely do nothing.
 177   base::Closure GetConnectCallback() {
 178     return base::Bind(&MockTriggerableClientSocket::DoCallback,
 179                       weak_factory_.GetWeakPtr());
 180   }
 181
 182   static scoped_ptr<StreamSocket> MakeMockPendingClientSocket(
 183       const AddressList& addrlist,
 184       bool should_connect,
 185       net::NetLog* net_log) {
 186     scoped_ptr<MockTriggerableClientSocket> socket(
 187         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
 188     base::MessageLoop::current()->PostTask(FROM_HERE,
 189                                            socket->GetConnectCallback());
 190     return socket.PassAs<StreamSocket>();
 191   }
 192
 193   static scoped_ptr<StreamSocket> MakeMockDelayedClientSocket(
 194       const AddressList& addrlist,
 195       bool should_connect,
 196       const base::TimeDelta& delay,
 197       net::NetLog* net_log) {
 198     scoped_ptr<MockTriggerableClientSocket> socket(
 199         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
 200     base::MessageLoop::current()->PostDelayedTask(
 201         FROM_HERE, socket->GetConnectCallback(), delay);
 202     return socket.PassAs<StreamSocket>();
 203   }
 204
 205   static scoped_ptr<StreamSocket> MakeMockStalledClientSocket(
 206       const AddressList& addrlist,
 207       net::NetLog* net_log) {
 208     scoped_ptr<MockTriggerableClientSocket> socket(
 209         new MockTriggerableClientSocket(addrlist, true, net_log));
 210     return socket.PassAs<StreamSocket>();
 211   }
 212
 213   // StreamSocket implementation.
 214   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
 215     DCHECK(callback_.is_null());
 216     callback_ = callback;
 217     return ERR_IO_PENDING;
 218   }
 219
 220   virtual void Disconnect() OVERRIDE {}
 221
 222   virtual bool IsConnected() const OVERRIDE { return is_connected_; }
 223   virtual bool IsConnectedAndIdle() const OVERRIDE { return is_connected_; }
 224   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
 225     *address = addrlist_.front();
 226     return OK;
 227   }
 228   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
 229     if (!is_connected_)
 230       return ERR_SOCKET_NOT_CONNECTED;
 231     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
 232       SetIPv4Address(address);
 233     else
 234       SetIPv6Address(address);
 235     return OK;
 236   }
 237   virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
 238
 239   virtual void SetSubresourceSpeculation() OVERRIDE {}
 240   virtual void SetOmniboxSpeculation() OVERRIDE {}
 241   virtual bool WasEverUsed() const OVERRIDE { return false; }
 242   virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
 243     use_tcp_fastopen_ = true;
 244   }
 245   virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
 246   virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
 247   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
 248     return kProtoUnknown;
 249   }
 250   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
 251
 252   // Socket implementation.
 253   virtual int Read(IOBuffer* buf,
 254                    int buf_len,
 255                    const CompletionCallback& callback) OVERRIDE {
 256     return ERR_FAILED;
 257   }
 258
 259   virtual int Write(IOBuffer* buf,
 260                     int buf_len,
 261                     const CompletionCallback& callback) OVERRIDE {
 262     return ERR_FAILED;
 263   }
 264   virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
 265   virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
 266
 267  private:
 268   void DoCallback() {
 269     is_connected_ = should_connect_;
 270     callback_.Run(is_connected_ ? OK : ERR_CONNECTION_FAILED);
 271   }
 272
 273   bool should_connect_;
 274   bool is_connected_;
 275   const AddressList addrlist_;
 276   BoundNetLog net_log_;
 277   CompletionCallback callback_;
 278   bool use_tcp_fastopen_;
 279
 280   base::WeakPtrFactory<MockTriggerableClientSocket> weak_factory_;
 281
 282   DISALLOW_COPY_AND_ASSIGN(MockTriggerableClientSocket);
 283 };
 284
 285 }  // namespace
 286
 287 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
 288   LoadTimingInfo load_timing_info;
 289   // Only pass true in as |is_reused|, as in general, HttpStream types should
 290   // have stricter concepts of reuse than socket pools.
 291   EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
 292
 293   EXPECT_TRUE(load_timing_info.socket_reused);
 294   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 295
 296   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 297   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 298 }
 299
 300 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
 301   EXPECT_FALSE(handle.is_reused());
 302
 303   LoadTimingInfo load_timing_info;
 304   EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
 305
 306   EXPECT_FALSE(load_timing_info.socket_reused);
 307   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 308
 309   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
 310                               CONNECT_TIMING_HAS_DNS_TIMES);
 311   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 312
 313   TestLoadTimingInfoConnectedReused(handle);
 314 }
 315
 316 void SetIPv4Address(IPEndPoint* address) {
 317   *address = IPEndPoint(ParseIP("1.1.1.1"), 80);
 318 }
 319
 320 void SetIPv6Address(IPEndPoint* address) {
 321   *address = IPEndPoint(ParseIP("1:abcd::3:4:ff"), 80);
 322 }
 323
 324 MockTransportClientSocketFactory::MockTransportClientSocketFactory(
 325     NetLog* net_log)
 326     : net_log_(net_log),
 327       allocation_count_(0),
 328       client_socket_type_(MOCK_CLIENT_SOCKET),
 329       client_socket_types_(NULL),
 330       client_socket_index_(0),
 331       client_socket_index_max_(0),
 332       delay_(base::TimeDelta::FromMilliseconds(
 333           ClientSocketPool::kMaxConnectRetryIntervalMs)) {}
 334
 335 MockTransportClientSocketFactory::~MockTransportClientSocketFactory() {}
 336
 337 scoped_ptr<DatagramClientSocket>
 338 MockTransportClientSocketFactory::CreateDatagramClientSocket(
 339     DatagramSocket::BindType bind_type,
 340     const RandIntCallback& rand_int_cb,
 341     NetLog* net_log,
 342     const NetLog::Source& source) {
 343   NOTREACHED();
 344   return scoped_ptr<DatagramClientSocket>();
 345 }
 346
 347 scoped_ptr<StreamSocket>
 348 MockTransportClientSocketFactory::CreateTransportClientSocket(
 349     const AddressList& addresses,
 350     NetLog* /* net_log */,
 351     const NetLog::Source& /* source */) {
 352   allocation_count_++;
 353
 354   ClientSocketType type = client_socket_type_;
 355   if (client_socket_types_ && client_socket_index_ < client_socket_index_max_) {
 356     type = client_socket_types_[client_socket_index_++];
 357   }
 358
 359   switch (type) {
 360     case MOCK_CLIENT_SOCKET:
 361       return scoped_ptr<StreamSocket>(
 362           new MockConnectClientSocket(addresses, net_log_));
 363     case MOCK_FAILING_CLIENT_SOCKET:
 364       return scoped_ptr<StreamSocket>(
 365           new MockFailingClientSocket(addresses, net_log_));
 366     case MOCK_PENDING_CLIENT_SOCKET:
 367       return MockTriggerableClientSocket::MakeMockPendingClientSocket(
 368           addresses, true, net_log_);
 369     case MOCK_PENDING_FAILING_CLIENT_SOCKET:
 370       return MockTriggerableClientSocket::MakeMockPendingClientSocket(
 371           addresses, false, net_log_);
 372     case MOCK_DELAYED_CLIENT_SOCKET:
 373       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
 374           addresses, true, delay_, net_log_);
 375     case MOCK_DELAYED_FAILING_CLIENT_SOCKET:
 376       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
 377           addresses, false, delay_, net_log_);
 378     case MOCK_STALLED_CLIENT_SOCKET:
 379       return MockTriggerableClientSocket::MakeMockStalledClientSocket(addresses,
 380                                                                       net_log_);
 381     case MOCK_TRIGGERABLE_CLIENT_SOCKET: {
 382       scoped_ptr<MockTriggerableClientSocket> rv(
 383           new MockTriggerableClientSocket(addresses, true, net_log_));
 384       triggerable_sockets_.push(rv->GetConnectCallback());
 385       // run_loop_quit_closure_ behaves like a condition variable. It will
 386       // wake up WaitForTriggerableSocketCreation() if it is sleeping. We
 387       // don't need to worry about atomicity because this code is
 388       // single-threaded.
 389       if (!run_loop_quit_closure_.is_null())
 390         run_loop_quit_closure_.Run();
 391       return rv.PassAs<StreamSocket>();
 392     }
 393     default:
 394       NOTREACHED();
 395       return scoped_ptr<StreamSocket>(
 396           new MockConnectClientSocket(addresses, net_log_));
 397   }
 398 }
 399
 400 scoped_ptr<SSLClientSocket>
 401 MockTransportClientSocketFactory::CreateSSLClientSocket(
 402     scoped_ptr<ClientSocketHandle> transport_socket,
 403     const HostPortPair& host_and_port,
 404     const SSLConfig& ssl_config,
 405     const SSLClientSocketContext& context) {
 406   NOTIMPLEMENTED();
 407   return scoped_ptr<SSLClientSocket>();
 408 }
 409
 410 void MockTransportClientSocketFactory::ClearSSLSessionCache() {
 411   NOTIMPLEMENTED();
 412 }
 413
 414 void MockTransportClientSocketFactory::set_client_socket_types(
 415     ClientSocketType* type_list,
 416     int num_types) {
 417   DCHECK_GT(num_types, 0);
 418   client_socket_types_ = type_list;
 419   client_socket_index_ = 0;
 420   client_socket_index_max_ = num_types;
 421 }
 422
 423 base::Closure
 424 MockTransportClientSocketFactory::WaitForTriggerableSocketCreation() {
 425   while (triggerable_sockets_.empty()) {
 426     base::RunLoop run_loop;
 427     run_loop_quit_closure_ = run_loop.QuitClosure();
 428     run_loop.Run();
 429     run_loop_quit_closure_.Reset();
 430   }
 431   base::Closure trigger = triggerable_sockets_.front();
 432   triggerable_sockets_.pop();
 433   return trigger;
 434 }
 435
 436 }  // namespace net