transport_client_socket_pool_test_util.cc 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470
  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. #include "net/socket/transport_client_socket_pool_test_util.h"
  5. #include <stdint.h>
  6. #include <string>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/check_op.h"
  10. #include "base/location.h"
  11. #include "base/memory/weak_ptr.h"
  12. #include "base/notreached.h"
  13. #include "base/run_loop.h"
  14. #include "base/task/single_thread_task_runner.h"
  15. #include "base/threading/thread_task_runner_handle.h"
  16. #include "net/base/ip_address.h"
  17. #include "net/base/ip_endpoint.h"
  18. #include "net/base/load_timing_info.h"
  19. #include "net/base/load_timing_info_test_util.h"
  20. #include "net/log/net_log_source.h"
  21. #include "net/log/net_log_source_type.h"
  22. #include "net/log/net_log_with_source.h"
  23. #include "net/socket/client_socket_handle.h"
  24. #include "net/socket/datagram_client_socket.h"
  25. #include "net/socket/ssl_client_socket.h"
  26. #include "net/socket/transport_client_socket.h"
  27. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  28. #include "testing/gtest/include/gtest/gtest.h"
  29. namespace net {
  30. namespace {
  31. IPAddress ParseIP(const std::string& ip) {
  32. IPAddress address;
  33. CHECK(address.AssignFromIPLiteral(ip));
  34. return address;
  35. }
  36. // A StreamSocket which connects synchronously and successfully.
  37. class MockConnectClientSocket : public TransportClientSocket {
  38. public:
  39. MockConnectClientSocket(const AddressList& addrlist, net::NetLog* net_log)
  40. : addrlist_(addrlist),
  41. net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
  42. MockConnectClientSocket(const MockConnectClientSocket&) = delete;
  43. MockConnectClientSocket& operator=(const MockConnectClientSocket&) = delete;
  44. // TransportClientSocket implementation.
  45. int Bind(const net::IPEndPoint& local_addr) override {
  46. NOTREACHED();
  47. return ERR_FAILED;
  48. }
  49. // StreamSocket implementation.
  50. int Connect(CompletionOnceCallback callback) override {
  51. connected_ = true;
  52. return OK;
  53. }
  54. void Disconnect() override { connected_ = false; }
  55. bool IsConnected() const override { return connected_; }
  56. bool IsConnectedAndIdle() const override { return connected_; }
  57. int GetPeerAddress(IPEndPoint* address) const override {
  58. *address = addrlist_.front();
  59. return OK;
  60. }
  61. int GetLocalAddress(IPEndPoint* address) const override {
  62. if (!connected_)
  63. return ERR_SOCKET_NOT_CONNECTED;
  64. if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
  65. SetIPv4Address(address);
  66. else
  67. SetIPv6Address(address);
  68. return OK;
  69. }
  70. const NetLogWithSource& NetLog() const override { return net_log_; }
  71. bool WasEverUsed() const override { return false; }
  72. bool WasAlpnNegotiated() const override { return false; }
  73. NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  74. bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
  75. int64_t GetTotalReceivedBytes() const override {
  76. NOTIMPLEMENTED();
  77. return 0;
  78. }
  79. void ApplySocketTag(const SocketTag& tag) override {}
  80. // Socket implementation.
  81. int Read(IOBuffer* buf,
  82. int buf_len,
  83. CompletionOnceCallback callback) override {
  84. return ERR_FAILED;
  85. }
  86. int Write(IOBuffer* buf,
  87. int buf_len,
  88. CompletionOnceCallback callback,
  89. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  90. return ERR_FAILED;
  91. }
  92. int SetReceiveBufferSize(int32_t size) override { return OK; }
  93. int SetSendBufferSize(int32_t size) override { return OK; }
  94. private:
  95. bool connected_ = false;
  96. const AddressList addrlist_;
  97. NetLogWithSource net_log_;
  98. };
  99. class MockFailingClientSocket : public TransportClientSocket {
  100. public:
  101. MockFailingClientSocket(const AddressList& addrlist,
  102. Error connect_error,
  103. net::NetLog* net_log)
  104. : addrlist_(addrlist),
  105. connect_error_(connect_error),
  106. net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
  107. MockFailingClientSocket(const MockFailingClientSocket&) = delete;
  108. MockFailingClientSocket& operator=(const MockFailingClientSocket&) = delete;
  109. // TransportClientSocket implementation.
  110. int Bind(const net::IPEndPoint& local_addr) override {
  111. NOTREACHED();
  112. return ERR_FAILED;
  113. }
  114. // StreamSocket implementation.
  115. int Connect(CompletionOnceCallback callback) override {
  116. return connect_error_;
  117. }
  118. void Disconnect() override {}
  119. bool IsConnected() const override { return false; }
  120. bool IsConnectedAndIdle() const override { return false; }
  121. int GetPeerAddress(IPEndPoint* address) const override {
  122. return ERR_UNEXPECTED;
  123. }
  124. int GetLocalAddress(IPEndPoint* address) const override {
  125. return ERR_UNEXPECTED;
  126. }
  127. const NetLogWithSource& NetLog() const override { return net_log_; }
  128. bool WasEverUsed() const override { return false; }
  129. bool WasAlpnNegotiated() const override { return false; }
  130. NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  131. bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
  132. int64_t GetTotalReceivedBytes() const override {
  133. NOTIMPLEMENTED();
  134. return 0;
  135. }
  136. void ApplySocketTag(const SocketTag& tag) override {}
  137. // Socket implementation.
  138. int Read(IOBuffer* buf,
  139. int buf_len,
  140. CompletionOnceCallback callback) override {
  141. return ERR_FAILED;
  142. }
  143. int Write(IOBuffer* buf,
  144. int buf_len,
  145. CompletionOnceCallback callback,
  146. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  147. return ERR_FAILED;
  148. }
  149. int SetReceiveBufferSize(int32_t size) override { return OK; }
  150. int SetSendBufferSize(int32_t size) override { return OK; }
  151. private:
  152. const AddressList addrlist_;
  153. const Error connect_error_;
  154. NetLogWithSource net_log_;
  155. };
  156. class MockTriggerableClientSocket : public TransportClientSocket {
  157. public:
  158. // |connect_error| indicates whether the socket should successfully complete
  159. // or fail.
  160. MockTriggerableClientSocket(const AddressList& addrlist,
  161. Error connect_error,
  162. net::NetLog* net_log)
  163. : connect_error_(connect_error),
  164. addrlist_(addrlist),
  165. net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
  166. MockTriggerableClientSocket(const MockTriggerableClientSocket&) = delete;
  167. MockTriggerableClientSocket& operator=(const MockTriggerableClientSocket&) =
  168. delete;
  169. // Call this method to get a closure which will trigger the connect callback
  170. // when called. The closure can be called even after the socket is deleted; it
  171. // will safely do nothing.
  172. base::OnceClosure GetConnectCallback() {
  173. return base::BindOnce(&MockTriggerableClientSocket::DoCallback,
  174. weak_factory_.GetWeakPtr());
  175. }
  176. static std::unique_ptr<TransportClientSocket> MakeMockPendingClientSocket(
  177. const AddressList& addrlist,
  178. Error connect_error,
  179. net::NetLog* net_log) {
  180. auto socket = std::make_unique<MockTriggerableClientSocket>(
  181. addrlist, connect_error, net_log);
  182. base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
  183. socket->GetConnectCallback());
  184. return std::move(socket);
  185. }
  186. static std::unique_ptr<TransportClientSocket> MakeMockDelayedClientSocket(
  187. const AddressList& addrlist,
  188. Error connect_error,
  189. const base::TimeDelta& delay,
  190. net::NetLog* net_log) {
  191. auto socket = std::make_unique<MockTriggerableClientSocket>(
  192. addrlist, connect_error, net_log);
  193. base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
  194. FROM_HERE, socket->GetConnectCallback(), delay);
  195. return std::move(socket);
  196. }
  197. static std::unique_ptr<TransportClientSocket> MakeMockStalledClientSocket(
  198. const AddressList& addrlist,
  199. net::NetLog* net_log) {
  200. // We never post `GetConnectCallback()`, so the value of `connect_error`
  201. // does not matter.
  202. return std::make_unique<MockTriggerableClientSocket>(
  203. addrlist, /*connect_error=*/OK, net_log);
  204. }
  205. // TransportClientSocket implementation.
  206. int Bind(const net::IPEndPoint& local_addr) override {
  207. NOTREACHED();
  208. return ERR_FAILED;
  209. }
  210. // StreamSocket implementation.
  211. int Connect(CompletionOnceCallback callback) override {
  212. DCHECK(callback_.is_null());
  213. callback_ = std::move(callback);
  214. return ERR_IO_PENDING;
  215. }
  216. void Disconnect() override {}
  217. bool IsConnected() const override { return is_connected_; }
  218. bool IsConnectedAndIdle() const override { return is_connected_; }
  219. int GetPeerAddress(IPEndPoint* address) const override {
  220. *address = addrlist_.front();
  221. return OK;
  222. }
  223. int GetLocalAddress(IPEndPoint* address) const override {
  224. if (!is_connected_)
  225. return ERR_SOCKET_NOT_CONNECTED;
  226. if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
  227. SetIPv4Address(address);
  228. else
  229. SetIPv6Address(address);
  230. return OK;
  231. }
  232. const NetLogWithSource& NetLog() const override { return net_log_; }
  233. bool WasEverUsed() const override { return false; }
  234. bool WasAlpnNegotiated() const override { return false; }
  235. NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  236. bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
  237. int64_t GetTotalReceivedBytes() const override {
  238. NOTIMPLEMENTED();
  239. return 0;
  240. }
  241. void ApplySocketTag(const SocketTag& tag) override {}
  242. // Socket implementation.
  243. int Read(IOBuffer* buf,
  244. int buf_len,
  245. CompletionOnceCallback callback) override {
  246. return ERR_FAILED;
  247. }
  248. int Write(IOBuffer* buf,
  249. int buf_len,
  250. CompletionOnceCallback callback,
  251. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  252. return ERR_FAILED;
  253. }
  254. int SetReceiveBufferSize(int32_t size) override { return OK; }
  255. int SetSendBufferSize(int32_t size) override { return OK; }
  256. private:
  257. void DoCallback() {
  258. is_connected_ = connect_error_ == OK;
  259. std::move(callback_).Run(connect_error_);
  260. }
  261. Error connect_error_;
  262. bool is_connected_ = false;
  263. const AddressList addrlist_;
  264. NetLogWithSource net_log_;
  265. CompletionOnceCallback callback_;
  266. base::WeakPtrFactory<MockTriggerableClientSocket> weak_factory_{this};
  267. };
  268. } // namespace
  269. void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
  270. LoadTimingInfo load_timing_info;
  271. // Only pass true in as |is_reused|, as in general, HttpStream types should
  272. // have stricter concepts of reuse than socket pools.
  273. EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
  274. EXPECT_TRUE(load_timing_info.socket_reused);
  275. EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
  276. ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
  277. ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  278. }
  279. void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
  280. EXPECT_FALSE(handle.is_reused());
  281. LoadTimingInfo load_timing_info;
  282. EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
  283. EXPECT_FALSE(load_timing_info.socket_reused);
  284. EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
  285. ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
  286. CONNECT_TIMING_HAS_DNS_TIMES);
  287. ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  288. TestLoadTimingInfoConnectedReused(handle);
  289. }
  290. void SetIPv4Address(IPEndPoint* address) {
  291. *address = IPEndPoint(ParseIP("1.1.1.1"), 80);
  292. }
  293. void SetIPv6Address(IPEndPoint* address) {
  294. *address = IPEndPoint(ParseIP("1:abcd::3:4:ff"), 80);
  295. }
  296. MockTransportClientSocketFactory::Rule::Rule(
  297. Type type,
  298. absl::optional<std::vector<IPEndPoint>> expected_addresses,
  299. Error connect_error)
  300. : type(type),
  301. expected_addresses(std::move(expected_addresses)),
  302. connect_error(connect_error) {}
  303. MockTransportClientSocketFactory::Rule::~Rule() = default;
  304. MockTransportClientSocketFactory::Rule::Rule(const Rule&) = default;
  305. MockTransportClientSocketFactory::Rule&
  306. MockTransportClientSocketFactory::Rule::operator=(const Rule&) = default;
  307. MockTransportClientSocketFactory::MockTransportClientSocketFactory(
  308. NetLog* net_log)
  309. : net_log_(net_log),
  310. delay_(base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs)) {
  311. }
  312. MockTransportClientSocketFactory::~MockTransportClientSocketFactory() = default;
  313. std::unique_ptr<DatagramClientSocket>
  314. MockTransportClientSocketFactory::CreateDatagramClientSocket(
  315. DatagramSocket::BindType bind_type,
  316. NetLog* net_log,
  317. const NetLogSource& source) {
  318. NOTREACHED();
  319. return nullptr;
  320. }
  321. std::unique_ptr<TransportClientSocket>
  322. MockTransportClientSocketFactory::CreateTransportClientSocket(
  323. const AddressList& addresses,
  324. std::unique_ptr<SocketPerformanceWatcher> /* socket_performance_watcher */,
  325. NetworkQualityEstimator* /* network_quality_estimator */,
  326. NetLog* /* net_log */,
  327. const NetLogSource& /* source */) {
  328. allocation_count_++;
  329. Rule rule(client_socket_type_);
  330. if (!rules_.empty()) {
  331. rule = rules_.front();
  332. rules_ = rules_.subspan(1);
  333. }
  334. if (rule.expected_addresses) {
  335. EXPECT_EQ(addresses.endpoints(), *rule.expected_addresses);
  336. }
  337. switch (rule.type) {
  338. case Type::kUnexpected:
  339. ADD_FAILURE() << "Unexpectedly created socket to "
  340. << addresses.endpoints().front();
  341. return std::make_unique<MockConnectClientSocket>(addresses, net_log_);
  342. case Type::kSynchronous:
  343. return std::make_unique<MockConnectClientSocket>(addresses, net_log_);
  344. case Type::kFailing:
  345. return std::make_unique<MockFailingClientSocket>(
  346. addresses, rule.connect_error, net_log_);
  347. case Type::kPending:
  348. return MockTriggerableClientSocket::MakeMockPendingClientSocket(
  349. addresses, OK, net_log_);
  350. case Type::kPendingFailing:
  351. return MockTriggerableClientSocket::MakeMockPendingClientSocket(
  352. addresses, rule.connect_error, net_log_);
  353. case Type::kDelayed:
  354. return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
  355. addresses, OK, delay_, net_log_);
  356. case Type::kDelayedFailing:
  357. return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
  358. addresses, rule.connect_error, delay_, net_log_);
  359. case Type::kStalled:
  360. return MockTriggerableClientSocket::MakeMockStalledClientSocket(addresses,
  361. net_log_);
  362. case Type::kTriggerable: {
  363. auto rv = std::make_unique<MockTriggerableClientSocket>(addresses, OK,
  364. net_log_);
  365. triggerable_sockets_.push(rv->GetConnectCallback());
  366. // run_loop_quit_closure_ behaves like a condition variable. It will
  367. // wake up WaitForTriggerableSocketCreation() if it is sleeping. We
  368. // don't need to worry about atomicity because this code is
  369. // single-threaded.
  370. if (!run_loop_quit_closure_.is_null())
  371. std::move(run_loop_quit_closure_).Run();
  372. return std::move(rv);
  373. }
  374. default:
  375. NOTREACHED();
  376. return std::make_unique<MockConnectClientSocket>(addresses, net_log_);
  377. }
  378. }
  379. std::unique_ptr<SSLClientSocket>
  380. MockTransportClientSocketFactory::CreateSSLClientSocket(
  381. SSLClientContext* context,
  382. std::unique_ptr<StreamSocket> stream_socket,
  383. const HostPortPair& host_and_port,
  384. const SSLConfig& ssl_config) {
  385. NOTIMPLEMENTED();
  386. return nullptr;
  387. }
  388. void MockTransportClientSocketFactory::SetRules(base::span<const Rule> rules) {
  389. DCHECK(rules_.empty());
  390. client_socket_type_ = Type::kUnexpected;
  391. rules_ = rules;
  392. }
  393. base::OnceClosure
  394. MockTransportClientSocketFactory::WaitForTriggerableSocketCreation() {
  395. while (triggerable_sockets_.empty()) {
  396. base::RunLoop run_loop;
  397. run_loop_quit_closure_ = run_loop.QuitClosure();
  398. run_loop.Run();
  399. run_loop_quit_closure_.Reset();
  400. }
  401. base::OnceClosure trigger = std::move(triggerable_sockets_.front());
  402. triggerable_sockets_.pop();
  403. return trigger;
  404. }
  405. } // namespace net