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