transport_client_socket_pool_unittest.cc 122 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/socket/transport_client_socket_pool.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback.h"
  9. #include "base/callback_helpers.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/memory/ref_counted.h"
  12. #include "base/run_loop.h"
  13. #include "base/test/bind.h"
  14. #include "base/test/scoped_feature_list.h"
  15. #include "base/threading/platform_thread.h"
  16. #include "build/build_config.h"
  17. #include "net/base/completion_once_callback.h"
  18. #include "net/base/features.h"
  19. #include "net/base/ip_endpoint.h"
  20. #include "net/base/load_timing_info.h"
  21. #include "net/base/load_timing_info_test_util.h"
  22. #include "net/base/net_errors.h"
  23. #include "net/base/privacy_mode.h"
  24. #include "net/base/proxy_server.h"
  25. #include "net/base/proxy_string_util.h"
  26. #include "net/base/schemeful_site.h"
  27. #include "net/base/test_completion_callback.h"
  28. #include "net/cert/ct_policy_enforcer.h"
  29. #include "net/cert/mock_cert_verifier.h"
  30. #include "net/dns/mock_host_resolver.h"
  31. #include "net/dns/public/secure_dns_policy.h"
  32. #include "net/http/http_network_session.h"
  33. #include "net/http/http_proxy_connect_job.h"
  34. #include "net/http/transport_security_state.h"
  35. #include "net/log/net_log.h"
  36. #include "net/log/net_log_with_source.h"
  37. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  38. #include "net/socket/client_socket_handle.h"
  39. #include "net/socket/connect_job.h"
  40. #include "net/socket/socket_tag.h"
  41. #include "net/socket/socket_test_util.h"
  42. #include "net/socket/socks_connect_job.h"
  43. #include "net/socket/ssl_connect_job.h"
  44. #include "net/socket/stream_socket.h"
  45. #include "net/socket/transport_client_socket_pool.h"
  46. #include "net/socket/transport_client_socket_pool_test_util.h"
  47. #include "net/socket/transport_connect_job.h"
  48. #include "net/spdy/spdy_test_util_common.h"
  49. #include "net/ssl/ssl_config_service.h"
  50. #include "net/test/embedded_test_server/embedded_test_server.h"
  51. #include "net/test/gtest_util.h"
  52. #include "net/test/test_with_task_environment.h"
  53. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  54. #include "testing/gmock/include/gmock/gmock.h"
  55. #include "testing/gtest/include/gtest/gtest.h"
  56. #include "third_party/abseil-cpp/absl/types/optional.h"
  57. #include "url/gurl.h"
  58. #include "url/scheme_host_port.h"
  59. #include "url/url_constants.h"
  60. using net::test::IsError;
  61. using net::test::IsOk;
  62. namespace net {
  63. namespace {
  64. const int kMaxSockets = 32;
  65. const int kMaxSocketsPerGroup = 6;
  66. constexpr base::TimeDelta kUnusedIdleSocketTimeout = base::Seconds(10);
  67. const RequestPriority kDefaultPriority = LOW;
  68. class SOCKS5MockData {
  69. public:
  70. explicit SOCKS5MockData(IoMode mode) {
  71. writes_ = std::make_unique<MockWrite[]>(2);
  72. writes_[0] =
  73. MockWrite(mode, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength);
  74. writes_[1] = MockWrite(mode, kSOCKS5OkRequest, kSOCKS5OkRequestLength);
  75. reads_ = std::make_unique<MockRead[]>(2);
  76. reads_[0] =
  77. MockRead(mode, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength);
  78. reads_[1] = MockRead(mode, kSOCKS5OkResponse, kSOCKS5OkResponseLength);
  79. data_ = std::make_unique<StaticSocketDataProvider>(
  80. base::make_span(reads_.get(), 2), base::make_span(writes_.get(), 2));
  81. }
  82. SocketDataProvider* data_provider() { return data_.get(); }
  83. private:
  84. std::unique_ptr<StaticSocketDataProvider> data_;
  85. std::unique_ptr<MockWrite[]> writes_;
  86. std::unique_ptr<MockRead[]> reads_;
  87. };
  88. class TransportClientSocketPoolTest : public ::testing::Test,
  89. public WithTaskEnvironment {
  90. public:
  91. TransportClientSocketPoolTest(const TransportClientSocketPoolTest&) = delete;
  92. TransportClientSocketPoolTest& operator=(
  93. const TransportClientSocketPoolTest&) = delete;
  94. protected:
  95. // Constructor that allows mocking of the time.
  96. explicit TransportClientSocketPoolTest(
  97. base::test::TaskEnvironment::TimeSource time_source =
  98. base::test::TaskEnvironment::TimeSource::DEFAULT)
  99. : WithTaskEnvironment(time_source),
  100. connect_backup_jobs_enabled_(
  101. TransportClientSocketPool::set_connect_backup_jobs_enabled(true)),
  102. group_id_(url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
  103. PrivacyMode::PRIVACY_MODE_DISABLED,
  104. NetworkIsolationKey(),
  105. SecureDnsPolicy::kAllow),
  106. params_(ClientSocketPool::SocketParams::CreateForHttpForTesting()),
  107. client_socket_factory_(NetLog::Get()) {
  108. std::unique_ptr<MockCertVerifier> cert_verifier =
  109. std::make_unique<MockCertVerifier>();
  110. cert_verifier->set_default_result(OK);
  111. session_deps_.cert_verifier = std::move(cert_verifier);
  112. http_network_session_ =
  113. SpdySessionDependencies::SpdyCreateSession(&session_deps_);
  114. common_connect_job_params_ = std::make_unique<CommonConnectJobParams>(
  115. http_network_session_->CreateCommonConnectJobParams());
  116. common_connect_job_params_->client_socket_factory = &client_socket_factory_;
  117. pool_ = std::make_unique<TransportClientSocketPool>(
  118. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  119. ProxyServer::Direct(), false /* is_for_websockets */,
  120. common_connect_job_params_.get());
  121. tagging_common_connect_job_params_ =
  122. std::make_unique<CommonConnectJobParams>(
  123. http_network_session_->CreateCommonConnectJobParams());
  124. tagging_common_connect_job_params_->client_socket_factory =
  125. &tagging_client_socket_factory_;
  126. tagging_pool_ = std::make_unique<TransportClientSocketPool>(
  127. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  128. ProxyServer::Direct(), false /* is_for_websockets */,
  129. tagging_common_connect_job_params_.get());
  130. common_connect_job_params_for_real_sockets_ =
  131. std::make_unique<CommonConnectJobParams>(
  132. http_network_session_->CreateCommonConnectJobParams());
  133. common_connect_job_params_for_real_sockets_->client_socket_factory =
  134. ClientSocketFactory::GetDefaultFactory();
  135. pool_for_real_sockets_ = std::make_unique<TransportClientSocketPool>(
  136. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  137. ProxyServer::Direct(), false /* is_for_websockets */,
  138. common_connect_job_params_for_real_sockets_.get());
  139. }
  140. ~TransportClientSocketPoolTest() override {
  141. TransportClientSocketPool::set_connect_backup_jobs_enabled(
  142. connect_backup_jobs_enabled_);
  143. }
  144. int StartRequest(const std::string& host_name, RequestPriority priority) {
  145. ClientSocketPool::GroupId group_id(
  146. url::SchemeHostPort(url::kHttpScheme, host_name, 80),
  147. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  148. SecureDnsPolicy::kAllow);
  149. return test_base_.StartRequestUsingPool(
  150. pool_.get(), group_id, priority,
  151. ClientSocketPool::RespectLimits::ENABLED,
  152. ClientSocketPool::SocketParams::CreateForHttpForTesting());
  153. }
  154. int GetOrderOfRequest(size_t index) {
  155. return test_base_.GetOrderOfRequest(index);
  156. }
  157. bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
  158. return test_base_.ReleaseOneConnection(keep_alive);
  159. }
  160. void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
  161. test_base_.ReleaseAllConnections(keep_alive);
  162. }
  163. std::vector<std::unique_ptr<TestSocketRequest>>* requests() {
  164. return test_base_.requests();
  165. }
  166. size_t completion_count() const { return test_base_.completion_count(); }
  167. bool connect_backup_jobs_enabled_;
  168. // |group_id_| and |params_| correspond to the same group.
  169. const ClientSocketPool::GroupId group_id_;
  170. scoped_refptr<ClientSocketPool::SocketParams> params_;
  171. MockTransportClientSocketFactory client_socket_factory_;
  172. MockTaggingClientSocketFactory tagging_client_socket_factory_;
  173. // None of these tests check SPDY behavior, but this is a convenient way to
  174. // create most objects needed by the socket pools, as well as a SpdySession
  175. // pool, which is required by HttpProxyConnectJobs when using an HTTPS proxy.
  176. SpdySessionDependencies session_deps_;
  177. // As with |session_deps_|, this is a convenient way to construct objects
  178. // these tests depend on.
  179. std::unique_ptr<HttpNetworkSession> http_network_session_;
  180. std::unique_ptr<CommonConnectJobParams> common_connect_job_params_;
  181. std::unique_ptr<TransportClientSocketPool> pool_;
  182. // Just like |pool_|, except it uses a real MockTaggingClientSocketFactory
  183. // instead of MockTransportClientSocketFactory.
  184. std::unique_ptr<CommonConnectJobParams> tagging_common_connect_job_params_;
  185. std::unique_ptr<TransportClientSocketPool> tagging_pool_;
  186. // Just like |pool_|, except it uses a real ClientSocketFactory instead of
  187. // |client_socket_factory_|.
  188. std::unique_ptr<CommonConnectJobParams>
  189. common_connect_job_params_for_real_sockets_;
  190. std::unique_ptr<TransportClientSocketPool> pool_for_real_sockets_;
  191. ClientSocketPoolTest test_base_;
  192. };
  193. TEST_F(TransportClientSocketPoolTest, Basic) {
  194. TestCompletionCallback callback;
  195. ClientSocketHandle handle;
  196. int rv =
  197. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  198. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  199. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  200. pool_.get(), NetLogWithSource());
  201. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  202. EXPECT_FALSE(handle.is_initialized());
  203. EXPECT_FALSE(handle.socket());
  204. EXPECT_THAT(callback.WaitForResult(), IsOk());
  205. EXPECT_TRUE(handle.is_initialized());
  206. EXPECT_TRUE(handle.socket());
  207. TestLoadTimingInfoConnectedNotReused(handle);
  208. EXPECT_EQ(0u, handle.connection_attempts().size());
  209. }
  210. // Make sure that TransportConnectJob passes on its priority to its
  211. // HostResolver request on Init.
  212. TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) {
  213. for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
  214. RequestPriority priority = static_cast<RequestPriority>(i);
  215. TestCompletionCallback callback;
  216. ClientSocketHandle handle;
  217. EXPECT_EQ(
  218. ERR_IO_PENDING,
  219. handle.Init(group_id_, params_,
  220. absl::nullopt /* proxy_annotation_tag */, priority,
  221. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  222. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  223. pool_.get(), NetLogWithSource()));
  224. EXPECT_EQ(priority, session_deps_.host_resolver->last_request_priority());
  225. }
  226. }
  227. TEST_F(TransportClientSocketPoolTest, SetSecureDnsPolicy) {
  228. for (auto secure_dns_policy :
  229. {SecureDnsPolicy::kAllow, SecureDnsPolicy::kDisable}) {
  230. TestCompletionCallback callback;
  231. ClientSocketHandle handle;
  232. ClientSocketPool::GroupId group_id(
  233. url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
  234. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  235. secure_dns_policy);
  236. EXPECT_EQ(
  237. ERR_IO_PENDING,
  238. handle.Init(group_id, params_, absl::nullopt /* proxy_annotation_tag */,
  239. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  240. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  241. pool_.get(), NetLogWithSource()));
  242. EXPECT_EQ(secure_dns_policy,
  243. session_deps_.host_resolver->last_secure_dns_policy());
  244. }
  245. }
  246. TEST_F(TransportClientSocketPoolTest, ReprioritizeRequests) {
  247. session_deps_.host_resolver->set_ondemand_mode(true);
  248. TestCompletionCallback callback1;
  249. ClientSocketHandle handle1;
  250. int rv1 =
  251. handle1.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  252. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  253. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  254. pool_.get(), NetLogWithSource());
  255. EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
  256. TestCompletionCallback callback2;
  257. ClientSocketHandle handle2;
  258. int rv2 = handle2.Init(
  259. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
  260. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  261. callback2.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  262. NetLogWithSource());
  263. EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
  264. TestCompletionCallback callback3;
  265. ClientSocketHandle handle3;
  266. int rv3 = handle3.Init(
  267. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOWEST,
  268. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  269. callback3.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  270. NetLogWithSource());
  271. EXPECT_THAT(rv3, IsError(ERR_IO_PENDING));
  272. TestCompletionCallback callback4;
  273. ClientSocketHandle handle4;
  274. int rv4 = handle4.Init(
  275. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, MEDIUM,
  276. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  277. callback4.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  278. NetLogWithSource());
  279. EXPECT_THAT(rv4, IsError(ERR_IO_PENDING));
  280. TestCompletionCallback callback5;
  281. ClientSocketHandle handle5;
  282. int rv5 = handle5.Init(
  283. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
  284. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  285. callback5.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  286. NetLogWithSource());
  287. EXPECT_THAT(rv5, IsError(ERR_IO_PENDING));
  288. TestCompletionCallback callback6;
  289. ClientSocketHandle handle6;
  290. int rv6 =
  291. handle6.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  292. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  293. callback6.callback(), ClientSocketPool::ProxyAuthCallback(),
  294. pool_.get(), NetLogWithSource());
  295. EXPECT_THAT(rv6, IsError(ERR_IO_PENDING));
  296. // New jobs are created for each of the first 6 requests with the
  297. // corresponding priority.
  298. //
  299. // Queue of pending requests:
  300. // Request Job Priority
  301. // ======= === ========
  302. // 2 2 HIGHEST
  303. // 5 5 HIGHEST
  304. // 4 4 MEDIUM
  305. // 1 1 LOW
  306. // 6 6 LOW
  307. // 3 3 LOWEST
  308. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  309. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
  310. EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(3));
  311. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
  312. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
  313. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
  314. // Inserting a highest-priority request steals the job from the lowest
  315. // priority request and reprioritizes it to match the new request.
  316. TestCompletionCallback callback7;
  317. ClientSocketHandle handle7;
  318. int rv7 = handle7.Init(
  319. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
  320. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  321. callback7.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  322. NetLogWithSource());
  323. EXPECT_THAT(rv7, IsError(ERR_IO_PENDING));
  324. // Request Job Priority
  325. // ======= === ========
  326. // 2 2 HIGHEST
  327. // 5 5 HIGHEST
  328. // 7 3 HIGHEST
  329. // 4 4 MEDIUM
  330. // 1 1 LOW
  331. // 6 6 LOW
  332. // 3 LOWEST
  333. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  334. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
  335. EXPECT_EQ(HIGHEST,
  336. session_deps_.host_resolver->request_priority(3)); // reprioritized
  337. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
  338. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
  339. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
  340. TestCompletionCallback callback8;
  341. ClientSocketHandle handle8;
  342. int rv8 = handle8.Init(
  343. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
  344. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  345. callback8.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  346. NetLogWithSource());
  347. EXPECT_THAT(rv8, IsError(ERR_IO_PENDING));
  348. // Request Job Priority
  349. // ======= === ========
  350. // 2 2 HIGHEST
  351. // 5 5 HIGHEST
  352. // 7 3 HIGHEST
  353. // 8 6 HIGHEST
  354. // 4 4 MEDIUM
  355. // 1 1 LOW
  356. // 6 LOW
  357. // 3 LOWEST
  358. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  359. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
  360. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(3));
  361. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
  362. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
  363. EXPECT_EQ(HIGHEST,
  364. session_deps_.host_resolver->request_priority(6)); // reprioritized
  365. // A request completes, then the socket is returned to the socket pool and
  366. // goes to the highest remaining request. The job from the highest request
  367. // should then be reassigned to the first request without a job.
  368. session_deps_.host_resolver->ResolveNow(2);
  369. EXPECT_THAT(callback2.WaitForResult(), IsOk());
  370. EXPECT_TRUE(handle2.is_initialized());
  371. EXPECT_TRUE(handle2.socket());
  372. handle2.Reset();
  373. EXPECT_THAT(callback5.WaitForResult(), IsOk());
  374. EXPECT_TRUE(handle5.is_initialized());
  375. EXPECT_TRUE(handle5.socket());
  376. // Request Job Priority
  377. // ======= === ========
  378. // 7 3 HIGHEST
  379. // 8 6 HIGHEST
  380. // 4 4 MEDIUM
  381. // 1 1 LOW
  382. // 6 5 LOW
  383. // 3 LOWEST
  384. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  385. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(3));
  386. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
  387. EXPECT_EQ(LOW,
  388. session_deps_.host_resolver->request_priority(5)); // reprioritized
  389. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
  390. // Cancelling a request with a job reassigns the job to a lower request.
  391. handle7.Reset();
  392. // Request Job Priority
  393. // ======= === ========
  394. // 8 6 HIGHEST
  395. // 4 4 MEDIUM
  396. // 1 1 LOW
  397. // 6 5 LOW
  398. // 3 3 LOWEST
  399. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  400. EXPECT_EQ(LOWEST,
  401. session_deps_.host_resolver->request_priority(3)); // reprioritized
  402. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
  403. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
  404. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
  405. // Reprioritizing a request changes its job's priority.
  406. pool_->SetPriority(group_id_, &handle4, LOWEST);
  407. // Request Job Priority
  408. // ======= === ========
  409. // 8 6 HIGHEST
  410. // 1 1 LOW
  411. // 6 5 LOW
  412. // 3 3 LOWEST
  413. // 4 4 LOWEST
  414. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  415. EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(3));
  416. EXPECT_EQ(LOWEST,
  417. session_deps_.host_resolver->request_priority(4)); // reprioritized
  418. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
  419. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
  420. pool_->SetPriority(group_id_, &handle3, MEDIUM);
  421. // Request Job Priority
  422. // ======= === ========
  423. // 8 6 HIGHEST
  424. // 3 3 MEDIUM
  425. // 1 1 LOW
  426. // 6 5 LOW
  427. // 4 4 LOWEST
  428. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  429. EXPECT_EQ(MEDIUM,
  430. session_deps_.host_resolver->request_priority(3)); // reprioritized
  431. EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
  432. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
  433. EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
  434. // Host resolution finishes for a lower-down request. The highest request
  435. // should get the socket and its job should be reassigned to the lower
  436. // request.
  437. session_deps_.host_resolver->ResolveNow(1);
  438. EXPECT_THAT(callback8.WaitForResult(), IsOk());
  439. EXPECT_TRUE(handle8.is_initialized());
  440. EXPECT_TRUE(handle8.socket());
  441. // Request Job Priority
  442. // ======= === ========
  443. // 3 3 MEDIUM
  444. // 1 6 LOW
  445. // 6 5 LOW
  446. // 4 4 LOWEST
  447. EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(3));
  448. EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
  449. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
  450. EXPECT_EQ(LOW,
  451. session_deps_.host_resolver->request_priority(6)); // reprioritized
  452. // Host resolution finishes for the highest request. Nothing gets
  453. // reprioritized.
  454. session_deps_.host_resolver->ResolveNow(3);
  455. EXPECT_THAT(callback3.WaitForResult(), IsOk());
  456. EXPECT_TRUE(handle3.is_initialized());
  457. EXPECT_TRUE(handle3.socket());
  458. // Request Job Priority
  459. // ======= === ========
  460. // 1 6 LOW
  461. // 6 5 LOW
  462. // 4 4 LOWEST
  463. EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
  464. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
  465. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
  466. session_deps_.host_resolver->ResolveAllPending();
  467. EXPECT_THAT(callback1.WaitForResult(), IsOk());
  468. EXPECT_TRUE(handle1.is_initialized());
  469. EXPECT_TRUE(handle1.socket());
  470. EXPECT_THAT(callback4.WaitForResult(), IsOk());
  471. EXPECT_TRUE(handle4.is_initialized());
  472. EXPECT_TRUE(handle4.socket());
  473. EXPECT_THAT(callback6.WaitForResult(), IsOk());
  474. EXPECT_TRUE(handle6.is_initialized());
  475. EXPECT_TRUE(handle6.socket());
  476. }
  477. TEST_F(TransportClientSocketPoolTest, RequestIgnoringLimitsIsReprioritized) {
  478. TransportClientSocketPool pool(
  479. kMaxSockets, 1, kUnusedIdleSocketTimeout, ProxyServer::Direct(),
  480. false /* is_for_websockets */, common_connect_job_params_.get());
  481. // Creates a job which ignores limits whose priority is MAXIMUM_PRIORITY.
  482. TestCompletionCallback callback1;
  483. ClientSocketHandle handle1;
  484. int rv1 = handle1.Init(
  485. group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  486. MAXIMUM_PRIORITY, SocketTag(), ClientSocketPool::RespectLimits::DISABLED,
  487. callback1.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
  488. NetLogWithSource());
  489. EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
  490. EXPECT_EQ(MAXIMUM_PRIORITY, session_deps_.host_resolver->request_priority(1));
  491. TestCompletionCallback callback2;
  492. ClientSocketHandle handle2;
  493. int rv2 =
  494. handle2.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  495. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  496. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  497. &pool, NetLogWithSource());
  498. EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
  499. // |handle2| gets assigned the job, which is reprioritized.
  500. handle1.Reset();
  501. EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
  502. }
  503. TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
  504. session_deps_.host_resolver->rules()->AddSimulatedTimeoutFailure(
  505. group_id_.destination().host());
  506. TestCompletionCallback callback;
  507. ClientSocketHandle handle;
  508. EXPECT_EQ(
  509. ERR_IO_PENDING,
  510. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  511. kDefaultPriority, SocketTag(),
  512. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  513. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  514. NetLogWithSource()));
  515. EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
  516. EXPECT_THAT(handle.resolve_error_info().error, IsError(ERR_DNS_TIMED_OUT));
  517. ASSERT_EQ(1u, handle.connection_attempts().size());
  518. EXPECT_TRUE(handle.connection_attempts()[0].endpoint.address().empty());
  519. EXPECT_THAT(handle.connection_attempts()[0].result,
  520. IsError(ERR_NAME_NOT_RESOLVED));
  521. }
  522. TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
  523. client_socket_factory_.set_default_client_socket_type(
  524. MockTransportClientSocketFactory::Type::kFailing);
  525. TestCompletionCallback callback;
  526. ClientSocketHandle handle;
  527. EXPECT_EQ(
  528. ERR_IO_PENDING,
  529. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  530. kDefaultPriority, SocketTag(),
  531. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  532. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  533. NetLogWithSource()));
  534. EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
  535. ASSERT_EQ(1u, handle.connection_attempts().size());
  536. EXPECT_EQ("127.0.0.1:80",
  537. handle.connection_attempts()[0].endpoint.ToString());
  538. EXPECT_THAT(handle.connection_attempts()[0].result,
  539. IsError(ERR_CONNECTION_FAILED));
  540. // Make the host resolutions complete synchronously this time.
  541. session_deps_.host_resolver->set_synchronous_mode(true);
  542. EXPECT_EQ(
  543. ERR_CONNECTION_FAILED,
  544. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  545. kDefaultPriority, SocketTag(),
  546. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  547. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  548. NetLogWithSource()));
  549. ASSERT_EQ(1u, handle.connection_attempts().size());
  550. EXPECT_EQ("127.0.0.1:80",
  551. handle.connection_attempts()[0].endpoint.ToString());
  552. EXPECT_THAT(handle.connection_attempts()[0].result,
  553. IsError(ERR_CONNECTION_FAILED));
  554. }
  555. TEST_F(TransportClientSocketPoolTest, PendingRequests) {
  556. // First request finishes asynchronously.
  557. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  558. EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
  559. // Make all subsequent host resolutions complete synchronously.
  560. session_deps_.host_resolver->set_synchronous_mode(true);
  561. // Rest of them finish synchronously, until we reach the per-group limit.
  562. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  563. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  564. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  565. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  566. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  567. // The rest are pending since we've used all active sockets.
  568. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  569. EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
  570. EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
  571. EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
  572. EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
  573. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  574. EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
  575. EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
  576. EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
  577. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  578. ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
  579. EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
  580. // One initial asynchronous request and then 10 pending requests.
  581. EXPECT_EQ(11U, completion_count());
  582. // First part of requests, all with the same priority, finishes in FIFO order.
  583. EXPECT_EQ(1, GetOrderOfRequest(1));
  584. EXPECT_EQ(2, GetOrderOfRequest(2));
  585. EXPECT_EQ(3, GetOrderOfRequest(3));
  586. EXPECT_EQ(4, GetOrderOfRequest(4));
  587. EXPECT_EQ(5, GetOrderOfRequest(5));
  588. EXPECT_EQ(6, GetOrderOfRequest(6));
  589. // Make sure that rest of the requests complete in the order of priority.
  590. EXPECT_EQ(7, GetOrderOfRequest(7));
  591. EXPECT_EQ(14, GetOrderOfRequest(8));
  592. EXPECT_EQ(15, GetOrderOfRequest(9));
  593. EXPECT_EQ(10, GetOrderOfRequest(10));
  594. EXPECT_EQ(13, GetOrderOfRequest(11));
  595. EXPECT_EQ(8, GetOrderOfRequest(12));
  596. EXPECT_EQ(16, GetOrderOfRequest(13));
  597. EXPECT_EQ(11, GetOrderOfRequest(14));
  598. EXPECT_EQ(12, GetOrderOfRequest(15));
  599. EXPECT_EQ(9, GetOrderOfRequest(16));
  600. // Make sure we test order of all requests made.
  601. EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
  602. }
  603. TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
  604. // First request finishes asynchronously.
  605. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  606. EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
  607. // Make all subsequent host resolutions complete synchronously.
  608. session_deps_.host_resolver->set_synchronous_mode(true);
  609. // Rest of them finish synchronously, until we reach the per-group limit.
  610. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  611. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  612. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  613. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  614. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  615. // The rest are pending since we've used all active sockets.
  616. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  617. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  618. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  619. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  620. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  621. ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
  622. // The pending requests should finish successfully.
  623. EXPECT_THAT((*requests())[6]->WaitForResult(), IsOk());
  624. EXPECT_THAT((*requests())[7]->WaitForResult(), IsOk());
  625. EXPECT_THAT((*requests())[8]->WaitForResult(), IsOk());
  626. EXPECT_THAT((*requests())[9]->WaitForResult(), IsOk());
  627. EXPECT_THAT((*requests())[10]->WaitForResult(), IsOk());
  628. EXPECT_EQ(static_cast<int>(requests()->size()),
  629. client_socket_factory_.allocation_count());
  630. // First asynchronous request, and then last 5 pending requests.
  631. EXPECT_EQ(6U, completion_count());
  632. }
  633. // This test will start up a RequestSocket() and then immediately Cancel() it.
  634. // The pending host resolution will eventually complete, and destroy the
  635. // ClientSocketPool which will crash if the group was not cleared properly.
  636. TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) {
  637. TestCompletionCallback callback;
  638. ClientSocketHandle handle;
  639. EXPECT_EQ(
  640. ERR_IO_PENDING,
  641. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  642. kDefaultPriority, SocketTag(),
  643. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  644. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  645. NetLogWithSource()));
  646. handle.Reset();
  647. }
  648. TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {
  649. ClientSocketHandle handle;
  650. TestCompletionCallback callback;
  651. ClientSocketHandle handle2;
  652. TestCompletionCallback callback2;
  653. EXPECT_EQ(
  654. ERR_IO_PENDING,
  655. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  656. kDefaultPriority, SocketTag(),
  657. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  658. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  659. NetLogWithSource()));
  660. EXPECT_EQ(
  661. ERR_IO_PENDING,
  662. handle2.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  663. kDefaultPriority, SocketTag(),
  664. ClientSocketPool::RespectLimits::ENABLED,
  665. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  666. pool_.get(), NetLogWithSource()));
  667. handle.Reset();
  668. EXPECT_THAT(callback2.WaitForResult(), IsOk());
  669. handle2.Reset();
  670. }
  671. TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {
  672. client_socket_factory_.set_default_client_socket_type(
  673. MockTransportClientSocketFactory::Type::kPending);
  674. ClientSocketHandle handle;
  675. TestCompletionCallback callback;
  676. EXPECT_EQ(
  677. ERR_IO_PENDING,
  678. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  679. kDefaultPriority, SocketTag(),
  680. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  681. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  682. NetLogWithSource()));
  683. handle.Reset();
  684. TestCompletionCallback callback2;
  685. EXPECT_EQ(
  686. ERR_IO_PENDING,
  687. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  688. kDefaultPriority, SocketTag(),
  689. ClientSocketPool::RespectLimits::ENABLED,
  690. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  691. pool_.get(), NetLogWithSource()));
  692. session_deps_.host_resolver->set_synchronous_mode(true);
  693. // At this point, handle has two ConnectingSockets out for it. Due to the
  694. // setting the mock resolver into synchronous mode, the host resolution for
  695. // both will return in the same loop of the MessageLoop. The client socket
  696. // is a pending socket, so the Connect() will asynchronously complete on the
  697. // next loop of the MessageLoop. That means that the first
  698. // ConnectingSocket will enter OnIOComplete, and then the second one will.
  699. // If the first one is not cancelled, it will advance the load state, and
  700. // then the second one will crash.
  701. EXPECT_THAT(callback2.WaitForResult(), IsOk());
  702. EXPECT_FALSE(callback.have_result());
  703. handle.Reset();
  704. }
  705. TEST_F(TransportClientSocketPoolTest, CancelRequest) {
  706. // First request finishes asynchronously.
  707. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  708. EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
  709. // Make all subsequent host resolutions complete synchronously.
  710. session_deps_.host_resolver->set_synchronous_mode(true);
  711. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  712. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  713. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  714. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  715. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
  716. // Reached per-group limit, queue up requests.
  717. EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
  718. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  719. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  720. EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
  721. EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
  722. EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
  723. EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
  724. EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
  725. EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
  726. EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
  727. // Cancel a request.
  728. size_t index_to_cancel = kMaxSocketsPerGroup + 2;
  729. EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
  730. (*requests())[index_to_cancel]->handle()->Reset();
  731. ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
  732. EXPECT_EQ(kMaxSocketsPerGroup,
  733. client_socket_factory_.allocation_count());
  734. EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
  735. EXPECT_EQ(1, GetOrderOfRequest(1));
  736. EXPECT_EQ(2, GetOrderOfRequest(2));
  737. EXPECT_EQ(3, GetOrderOfRequest(3));
  738. EXPECT_EQ(4, GetOrderOfRequest(4));
  739. EXPECT_EQ(5, GetOrderOfRequest(5));
  740. EXPECT_EQ(6, GetOrderOfRequest(6));
  741. EXPECT_EQ(14, GetOrderOfRequest(7));
  742. EXPECT_EQ(7, GetOrderOfRequest(8));
  743. EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
  744. GetOrderOfRequest(9)); // Canceled request.
  745. EXPECT_EQ(9, GetOrderOfRequest(10));
  746. EXPECT_EQ(10, GetOrderOfRequest(11));
  747. EXPECT_EQ(11, GetOrderOfRequest(12));
  748. EXPECT_EQ(8, GetOrderOfRequest(13));
  749. EXPECT_EQ(12, GetOrderOfRequest(14));
  750. EXPECT_EQ(13, GetOrderOfRequest(15));
  751. EXPECT_EQ(15, GetOrderOfRequest(16));
  752. // Make sure we test order of all requests made.
  753. EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
  754. }
  755. class RequestSocketCallback : public TestCompletionCallbackBase {
  756. public:
  757. RequestSocketCallback(
  758. const ClientSocketPool::GroupId& group_id,
  759. scoped_refptr<ClientSocketPool::SocketParams> socket_params,
  760. ClientSocketHandle* handle,
  761. TransportClientSocketPool* pool)
  762. : group_id_(group_id),
  763. socket_params_(socket_params),
  764. handle_(handle),
  765. pool_(pool) {}
  766. RequestSocketCallback(const RequestSocketCallback&) = delete;
  767. RequestSocketCallback& operator=(const RequestSocketCallback&) = delete;
  768. ~RequestSocketCallback() override = default;
  769. CompletionOnceCallback callback() {
  770. return base::BindOnce(&RequestSocketCallback::OnComplete,
  771. base::Unretained(this));
  772. }
  773. private:
  774. void OnComplete(int result) {
  775. SetResult(result);
  776. ASSERT_THAT(result, IsOk());
  777. if (!within_callback_) {
  778. // Don't allow reuse of the socket. Disconnect it and then release it and
  779. // run through the MessageLoop once to get it completely released.
  780. handle_->socket()->Disconnect();
  781. handle_->Reset();
  782. base::RunLoop(base::RunLoop::Type::kNestableTasksAllowed).RunUntilIdle();
  783. within_callback_ = true;
  784. int rv = handle_->Init(
  785. group_id_, socket_params_, absl::nullopt /* proxy_annotation_tag */,
  786. LOWEST, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  787. callback(), ClientSocketPool::ProxyAuthCallback(), pool_,
  788. NetLogWithSource());
  789. EXPECT_THAT(rv, IsOk());
  790. }
  791. }
  792. const ClientSocketPool::GroupId group_id_;
  793. scoped_refptr<ClientSocketPool::SocketParams> socket_params_;
  794. const raw_ptr<ClientSocketHandle> handle_;
  795. const raw_ptr<TransportClientSocketPool> pool_;
  796. bool within_callback_ = false;
  797. };
  798. TEST_F(TransportClientSocketPoolTest, RequestTwice) {
  799. ClientSocketHandle handle;
  800. RequestSocketCallback callback(group_id_, params_, &handle, pool_.get());
  801. int rv =
  802. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  803. LOWEST, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  804. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  805. pool_.get(), NetLogWithSource());
  806. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  807. // The callback is going to request "www.google.com". We want it to complete
  808. // synchronously this time.
  809. session_deps_.host_resolver->set_synchronous_mode(true);
  810. EXPECT_THAT(callback.WaitForResult(), IsOk());
  811. handle.Reset();
  812. }
  813. // Make sure that pending requests get serviced after active requests get
  814. // cancelled.
  815. TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {
  816. client_socket_factory_.set_default_client_socket_type(
  817. MockTransportClientSocketFactory::Type::kPending);
  818. // Queue up all the requests
  819. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  820. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  821. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  822. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  823. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  824. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  825. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  826. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  827. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  828. // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them.
  829. ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size()));
  830. for (int i = 0; i < kMaxSocketsPerGroup; i++)
  831. (*requests())[i]->handle()->Reset();
  832. // Let's wait for the rest to complete now.
  833. for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) {
  834. EXPECT_THAT((*requests())[i]->WaitForResult(), IsOk());
  835. (*requests())[i]->handle()->Reset();
  836. }
  837. EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
  838. }
  839. // Make sure that pending requests get serviced after active requests fail.
  840. TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
  841. client_socket_factory_.set_default_client_socket_type(
  842. MockTransportClientSocketFactory::Type::kPendingFailing);
  843. const int kNumRequests = 2 * kMaxSocketsPerGroup + 1;
  844. ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang.
  845. // Queue up all the requests
  846. for (int i = 0; i < kNumRequests; i++)
  847. EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
  848. for (int i = 0; i < kNumRequests; i++)
  849. EXPECT_THAT((*requests())[i]->WaitForResult(),
  850. IsError(ERR_CONNECTION_FAILED));
  851. }
  852. TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {
  853. TestCompletionCallback callback;
  854. ClientSocketHandle handle;
  855. int rv =
  856. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  857. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  858. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  859. pool_.get(), NetLogWithSource());
  860. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  861. EXPECT_FALSE(handle.is_initialized());
  862. EXPECT_FALSE(handle.socket());
  863. EXPECT_THAT(callback.WaitForResult(), IsOk());
  864. EXPECT_TRUE(handle.is_initialized());
  865. EXPECT_TRUE(handle.socket());
  866. TestLoadTimingInfoConnectedNotReused(handle);
  867. handle.Reset();
  868. // Need to run all pending to release the socket back to the pool.
  869. base::RunLoop().RunUntilIdle();
  870. // Now we should have 1 idle socket.
  871. EXPECT_EQ(1, pool_->IdleSocketCount());
  872. rv = handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  873. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  874. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  875. pool_.get(), NetLogWithSource());
  876. EXPECT_THAT(rv, IsOk());
  877. EXPECT_EQ(0, pool_->IdleSocketCount());
  878. TestLoadTimingInfoConnectedReused(handle);
  879. }
  880. TEST_F(TransportClientSocketPoolTest, CloseIdleSocketsOnIPAddressChange) {
  881. TestCompletionCallback callback;
  882. ClientSocketHandle handle;
  883. int rv =
  884. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  885. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  886. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  887. pool_.get(), NetLogWithSource());
  888. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  889. EXPECT_FALSE(handle.is_initialized());
  890. EXPECT_FALSE(handle.socket());
  891. EXPECT_THAT(callback.WaitForResult(), IsOk());
  892. EXPECT_TRUE(handle.is_initialized());
  893. EXPECT_TRUE(handle.socket());
  894. handle.Reset();
  895. // Need to run all pending to release the socket back to the pool.
  896. base::RunLoop().RunUntilIdle();
  897. // Now we should have 1 idle socket.
  898. EXPECT_EQ(1, pool_->IdleSocketCount());
  899. // After an IP address change, we should have 0 idle sockets.
  900. NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
  901. base::RunLoop().RunUntilIdle(); // Notification happens async.
  902. EXPECT_EQ(0, pool_->IdleSocketCount());
  903. }
  904. TEST(TransportClientSocketPoolStandaloneTest, DontCleanupOnIPAddressChange) {
  905. // This test manually sets things up in the same way
  906. // TransportClientSocketPoolTest does, but it creates a
  907. // TransportClientSocketPool with cleanup_on_ip_address_changed = false. Since
  908. // this is the only test doing this, it's not worth extending
  909. // TransportClientSocketPoolTest to support this scenario.
  910. base::test::SingleThreadTaskEnvironment task_environment;
  911. std::unique_ptr<MockCertVerifier> cert_verifier =
  912. std::make_unique<MockCertVerifier>();
  913. SpdySessionDependencies session_deps;
  914. session_deps.cert_verifier = std::move(cert_verifier);
  915. std::unique_ptr<HttpNetworkSession> http_network_session =
  916. SpdySessionDependencies::SpdyCreateSession(&session_deps);
  917. auto common_connect_job_params = std::make_unique<CommonConnectJobParams>(
  918. http_network_session->CreateCommonConnectJobParams());
  919. MockTransportClientSocketFactory client_socket_factory(NetLog::Get());
  920. common_connect_job_params->client_socket_factory = &client_socket_factory;
  921. scoped_refptr<ClientSocketPool::SocketParams> params(
  922. ClientSocketPool::SocketParams::CreateForHttpForTesting());
  923. auto pool = std::make_unique<TransportClientSocketPool>(
  924. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  925. ProxyServer::Direct(), false /* is_for_websockets */,
  926. common_connect_job_params.get(),
  927. false /* cleanup_on_ip_address_change */);
  928. const ClientSocketPool::GroupId group_id(
  929. url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
  930. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  931. SecureDnsPolicy::kAllow);
  932. TestCompletionCallback callback;
  933. ClientSocketHandle handle;
  934. int rv =
  935. handle.Init(group_id, params, absl::nullopt /* proxy_annotation_tag */,
  936. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  937. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  938. pool.get(), NetLogWithSource());
  939. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  940. EXPECT_FALSE(handle.is_initialized());
  941. EXPECT_FALSE(handle.socket());
  942. EXPECT_THAT(callback.WaitForResult(), IsOk());
  943. EXPECT_TRUE(handle.is_initialized());
  944. EXPECT_TRUE(handle.socket());
  945. handle.Reset();
  946. // Need to run all pending to release the socket back to the pool.
  947. base::RunLoop().RunUntilIdle();
  948. // Now we should have 1 idle socket.
  949. EXPECT_EQ(1, pool->IdleSocketCount());
  950. // Since we set cleanup_on_ip_address_change = false, we should still have 1
  951. // idle socket after an IP address change.
  952. NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
  953. base::RunLoop().RunUntilIdle(); // Notification happens async.
  954. EXPECT_EQ(1, pool->IdleSocketCount());
  955. }
  956. TEST_F(TransportClientSocketPoolTest, SSLCertError) {
  957. StaticSocketDataProvider data;
  958. tagging_client_socket_factory_.AddSocketDataProvider(&data);
  959. SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID);
  960. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl);
  961. const url::SchemeHostPort kEndpoint(url::kHttpsScheme, "ssl.server.test",
  962. 443);
  963. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  964. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  965. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  966. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  967. std::move(ssl_config_for_origin),
  968. /*ssl_config_for_proxy=*/nullptr);
  969. ClientSocketHandle handle;
  970. TestCompletionCallback callback;
  971. int rv = handle.Init(
  972. ClientSocketPool::GroupId(kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED,
  973. NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  974. socket_params, absl::nullopt /* proxy_annotation_tag */, MEDIUM,
  975. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  976. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  977. tagging_pool_.get(), NetLogWithSource());
  978. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  979. EXPECT_FALSE(handle.is_initialized());
  980. EXPECT_FALSE(handle.socket());
  981. EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CERT_COMMON_NAME_INVALID));
  982. EXPECT_TRUE(handle.is_initialized());
  983. EXPECT_TRUE(handle.socket());
  984. }
  985. TEST_F(TransportClientSocketPoolTest, CloseIdleSocketsOnSSLConfigChange) {
  986. TestCompletionCallback callback;
  987. ClientSocketHandle handle;
  988. int rv =
  989. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  990. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  991. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  992. pool_.get(), NetLogWithSource());
  993. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  994. EXPECT_FALSE(handle.is_initialized());
  995. EXPECT_FALSE(handle.socket());
  996. EXPECT_THAT(callback.WaitForResult(), IsOk());
  997. EXPECT_TRUE(handle.is_initialized());
  998. EXPECT_TRUE(handle.socket());
  999. handle.Reset();
  1000. // Need to run all pending to release the socket back to the pool.
  1001. base::RunLoop().RunUntilIdle();
  1002. // Now we should have 1 idle socket.
  1003. EXPECT_EQ(1, pool_->IdleSocketCount());
  1004. // After an SSL configuration change, we should have 0 idle sockets.
  1005. session_deps_.ssl_config_service->NotifySSLContextConfigChange();
  1006. base::RunLoop().RunUntilIdle(); // Notification happens async.
  1007. EXPECT_EQ(0, pool_->IdleSocketCount());
  1008. }
  1009. TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {
  1010. // Case 1 tests the first socket stalling, and the backup connecting.
  1011. MockTransportClientSocketFactory::Rule rules1[] = {
  1012. // The first socket will not connect.
  1013. MockTransportClientSocketFactory::Rule(
  1014. MockTransportClientSocketFactory::Type::kStalled),
  1015. // The second socket will connect more quickly.
  1016. MockTransportClientSocketFactory::Rule(
  1017. MockTransportClientSocketFactory::Type::kSynchronous),
  1018. };
  1019. // Case 2 tests the first socket being slow, so that we start the
  1020. // second connect, but the second connect stalls, and we still
  1021. // complete the first.
  1022. MockTransportClientSocketFactory::Rule rules2[] = {
  1023. // The first socket will connect, although delayed.
  1024. MockTransportClientSocketFactory::Rule(
  1025. MockTransportClientSocketFactory::Type::kDelayed),
  1026. // The second socket will not connect.
  1027. MockTransportClientSocketFactory::Rule(
  1028. MockTransportClientSocketFactory::Type::kStalled),
  1029. };
  1030. base::span<const MockTransportClientSocketFactory::Rule> cases[2] = {rules1,
  1031. rules2};
  1032. for (auto rules : cases) {
  1033. client_socket_factory_.SetRules(rules);
  1034. EXPECT_EQ(0, pool_->IdleSocketCount());
  1035. TestCompletionCallback callback;
  1036. ClientSocketHandle handle;
  1037. int rv = handle.Init(
  1038. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOW,
  1039. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1040. callback.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  1041. NetLogWithSource());
  1042. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1043. EXPECT_FALSE(handle.is_initialized());
  1044. EXPECT_FALSE(handle.socket());
  1045. // Create the first socket, set the timer.
  1046. base::RunLoop().RunUntilIdle();
  1047. // Wait for the backup socket timer to fire.
  1048. base::PlatformThread::Sleep(
  1049. base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs + 50));
  1050. // Let the appropriate socket connect.
  1051. base::RunLoop().RunUntilIdle();
  1052. EXPECT_THAT(callback.WaitForResult(), IsOk());
  1053. EXPECT_TRUE(handle.is_initialized());
  1054. EXPECT_TRUE(handle.socket());
  1055. // One socket is stalled, the other is active.
  1056. EXPECT_EQ(0, pool_->IdleSocketCount());
  1057. handle.Reset();
  1058. // Close all pending connect jobs and existing sockets.
  1059. pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
  1060. }
  1061. }
  1062. // Test the case where a socket took long enough to start the creation
  1063. // of the backup socket, but then we cancelled the request after that.
  1064. TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {
  1065. client_socket_factory_.set_default_client_socket_type(
  1066. MockTransportClientSocketFactory::Type::kStalled);
  1067. enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
  1068. for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
  1069. EXPECT_EQ(0, pool_->IdleSocketCount());
  1070. TestCompletionCallback callback;
  1071. ClientSocketHandle handle;
  1072. int rv = handle.Init(
  1073. group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOW,
  1074. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1075. callback.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  1076. NetLogWithSource());
  1077. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1078. EXPECT_FALSE(handle.is_initialized());
  1079. EXPECT_FALSE(handle.socket());
  1080. // Create the first socket, set the timer.
  1081. base::RunLoop().RunUntilIdle();
  1082. if (index == CANCEL_AFTER_WAIT) {
  1083. // Wait for the backup socket timer to fire.
  1084. base::PlatformThread::Sleep(
  1085. base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
  1086. }
  1087. // Let the appropriate socket connect.
  1088. base::RunLoop().RunUntilIdle();
  1089. handle.Reset();
  1090. EXPECT_FALSE(callback.have_result());
  1091. EXPECT_FALSE(handle.is_initialized());
  1092. EXPECT_FALSE(handle.socket());
  1093. // One socket is stalled, the other is active.
  1094. EXPECT_EQ(0, pool_->IdleSocketCount());
  1095. }
  1096. }
  1097. // Test the case where a socket took long enough to start the creation
  1098. // of the backup socket and never completes, and then the backup
  1099. // connection fails.
  1100. TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {
  1101. MockTransportClientSocketFactory::Rule rules[] = {
  1102. // The first socket will not connect.
  1103. MockTransportClientSocketFactory::Rule(
  1104. MockTransportClientSocketFactory::Type::kStalled),
  1105. // The second socket will fail immediately.
  1106. MockTransportClientSocketFactory::Rule(
  1107. MockTransportClientSocketFactory::Type::kFailing),
  1108. };
  1109. client_socket_factory_.SetRules(rules);
  1110. EXPECT_EQ(0, pool_->IdleSocketCount());
  1111. TestCompletionCallback callback;
  1112. ClientSocketHandle handle;
  1113. int rv =
  1114. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  1115. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1116. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1117. pool_.get(), NetLogWithSource());
  1118. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1119. EXPECT_FALSE(handle.is_initialized());
  1120. EXPECT_FALSE(handle.socket());
  1121. // Create the first socket, set the timer.
  1122. base::RunLoop().RunUntilIdle();
  1123. // Wait for the backup socket timer to fire.
  1124. base::PlatformThread::Sleep(
  1125. base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
  1126. // Let the second connect be synchronous. Otherwise, the emulated
  1127. // host resolution takes an extra trip through the message loop.
  1128. session_deps_.host_resolver->set_synchronous_mode(true);
  1129. // Let the appropriate socket connect.
  1130. base::RunLoop().RunUntilIdle();
  1131. EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
  1132. EXPECT_FALSE(handle.is_initialized());
  1133. EXPECT_FALSE(handle.socket());
  1134. ASSERT_EQ(1u, handle.connection_attempts().size());
  1135. EXPECT_THAT(handle.connection_attempts()[0].result,
  1136. IsError(ERR_CONNECTION_FAILED));
  1137. EXPECT_EQ(0, pool_->IdleSocketCount());
  1138. handle.Reset();
  1139. }
  1140. // Test the case where a socket took long enough to start the creation
  1141. // of the backup socket and eventually completes, but the backup socket
  1142. // fails.
  1143. TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {
  1144. MockTransportClientSocketFactory::Rule rules[] = {
  1145. // The first socket will connect, although delayed.
  1146. MockTransportClientSocketFactory::Rule(
  1147. MockTransportClientSocketFactory::Type::kDelayed),
  1148. // The second socket will not connect.
  1149. MockTransportClientSocketFactory::Rule(
  1150. MockTransportClientSocketFactory::Type::kFailing),
  1151. };
  1152. client_socket_factory_.SetRules(rules);
  1153. client_socket_factory_.set_delay(base::Seconds(5));
  1154. EXPECT_EQ(0, pool_->IdleSocketCount());
  1155. TestCompletionCallback callback;
  1156. ClientSocketHandle handle;
  1157. int rv =
  1158. handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
  1159. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1160. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1161. pool_.get(), NetLogWithSource());
  1162. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1163. EXPECT_FALSE(handle.is_initialized());
  1164. EXPECT_FALSE(handle.socket());
  1165. // Create the first socket, set the timer.
  1166. base::RunLoop().RunUntilIdle();
  1167. // Wait for the backup socket timer to fire.
  1168. base::PlatformThread::Sleep(
  1169. base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
  1170. // Let the second connect be synchronous. Otherwise, the emulated
  1171. // host resolution takes an extra trip through the message loop.
  1172. session_deps_.host_resolver->set_synchronous_mode(true);
  1173. // Let the appropriate socket connect.
  1174. base::RunLoop().RunUntilIdle();
  1175. EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
  1176. EXPECT_FALSE(handle.is_initialized());
  1177. EXPECT_FALSE(handle.socket());
  1178. ASSERT_EQ(1u, handle.connection_attempts().size());
  1179. EXPECT_THAT(handle.connection_attempts()[0].result,
  1180. IsError(ERR_CONNECTION_FAILED));
  1181. handle.Reset();
  1182. }
  1183. // Test the case that SOCKSSocketParams are provided.
  1184. TEST_F(TransportClientSocketPoolTest, SOCKS) {
  1185. const url::SchemeHostPort kDestination(url::kHttpScheme, "host", 80);
  1186. TransportClientSocketPool proxy_pool(
  1187. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  1188. ProxyUriToProxyServer("socks5://foopy",
  1189. ProxyServer::SCHEME_HTTP /* default_scheme */),
  1190. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1191. for (IoMode socket_io_mode : {SYNCHRONOUS, ASYNC}) {
  1192. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  1193. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1194. nullptr /* ssl_config_for_origin */,
  1195. nullptr /* ssl_config_for_proxy */);
  1196. SOCKS5MockData data(socket_io_mode);
  1197. data.data_provider()->set_connect_data(MockConnect(socket_io_mode, OK));
  1198. tagging_client_socket_factory_.AddSocketDataProvider(data.data_provider());
  1199. ClientSocketHandle handle;
  1200. TestCompletionCallback callback;
  1201. int rv = handle.Init(
  1202. ClientSocketPool::GroupId(
  1203. kDestination, PrivacyMode::PRIVACY_MODE_DISABLED,
  1204. NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  1205. socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1206. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  1207. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  1208. EXPECT_THAT(callback.GetResult(rv), IsOk());
  1209. EXPECT_TRUE(handle.is_initialized());
  1210. EXPECT_TRUE(handle.socket());
  1211. EXPECT_TRUE(data.data_provider()->AllReadDataConsumed());
  1212. EXPECT_TRUE(data.data_provider()->AllWriteDataConsumed());
  1213. }
  1214. }
  1215. // Make sure there's no crash when an auth challenge is received over HTTP2
  1216. // and there are two pending Requests to the socket pool, with a single
  1217. // ConnectJob.
  1218. //
  1219. // See https://crbug.com/940848
  1220. TEST_F(TransportClientSocketPoolTest, SpdyOneConnectJobTwoRequestsError) {
  1221. const url::SchemeHostPort kEndpoint(url::kHttpsScheme,
  1222. "unresolvable.host.name", 443);
  1223. session_deps_.host_resolver->set_synchronous_mode(true);
  1224. // Create a socket pool which only allows a single connection at a time.
  1225. TransportClientSocketPool pool(
  1226. 1, 1, kUnusedIdleSocketTimeout,
  1227. ProxyUriToProxyServer("https://unresolvable.proxy.name",
  1228. ProxyServer::SCHEME_HTTP /* default_scheme */),
  1229. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1230. // First connection attempt will get an error after creating the SpdyStream.
  1231. SpdyTestUtil spdy_util;
  1232. spdy::SpdySerializedFrame connect(spdy_util.ConstructSpdyConnect(
  1233. nullptr, 0, 1, HttpProxyConnectJob::kH2QuicTunnelPriority,
  1234. HostPortPair::FromSchemeHostPort(kEndpoint)));
  1235. MockWrite writes[] = {
  1236. CreateMockWrite(connect, 0, ASYNC),
  1237. MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 2),
  1238. };
  1239. MockRead reads[] = {
  1240. MockRead(ASYNC, ERR_FAILED, 1),
  1241. };
  1242. SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
  1243. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
  1244. SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
  1245. ssl_data.next_proto = kProtoHTTP2;
  1246. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
  1247. // Second connection also fails. Not a vital part of this test, but allows
  1248. // waiting for the second request to complete without too much extra code.
  1249. SequencedSocketData socket_data2(
  1250. MockConnect(SYNCHRONOUS, ERR_CONNECTION_TIMED_OUT),
  1251. base::span<const MockRead>(), base::span<const MockWrite>());
  1252. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data2);
  1253. SSLSocketDataProvider ssl_data2(SYNCHRONOUS, OK);
  1254. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data2);
  1255. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  1256. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1257. std::make_unique<SSLConfig>() /* ssl_config_for_origin */,
  1258. std::make_unique<SSLConfig>() /* ssl_config_for_proxy */);
  1259. ClientSocketPool::GroupId group_id(
  1260. kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1261. SecureDnsPolicy::kAllow);
  1262. // Start the first connection attempt.
  1263. TestCompletionCallback callback1;
  1264. ClientSocketHandle handle1;
  1265. int rv1 = handle1.Init(
  1266. group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, HIGHEST,
  1267. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1268. callback1.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
  1269. NetLogWithSource());
  1270. ASSERT_THAT(rv1, IsError(ERR_IO_PENDING));
  1271. // Create a second request with a lower priority.
  1272. TestCompletionCallback callback2;
  1273. ClientSocketHandle handle2;
  1274. int rv2 = handle2.Init(
  1275. group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOWEST,
  1276. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1277. callback2.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
  1278. NetLogWithSource());
  1279. ASSERT_THAT(rv2, IsError(ERR_IO_PENDING));
  1280. // First connection fails after creating a SpdySession and a SpdyStream on
  1281. // that session. The SpdyStream will be destroyed under the
  1282. // SpdyProxyClientSocket. The failure will result in temporarily assigning the
  1283. // failed ConnectJob to the second request, which results in an unneeded
  1284. // reprioritization, which should not dereference the null SpdyStream.
  1285. //
  1286. // TODO(mmenke): Avoid that temporary reassignment.
  1287. ASSERT_THAT(callback1.WaitForResult(), IsError(ERR_FAILED));
  1288. // Second connection fails, getting a connection error.
  1289. ASSERT_THAT(callback2.WaitForResult(), IsError(ERR_PROXY_CONNECTION_FAILED));
  1290. }
  1291. // Make sure there's no crash when an auth challenge is received over HTTP2
  1292. // and there are two pending Requests to the socket pool, with a single
  1293. // ConnectJob.
  1294. //
  1295. // See https://crbug.com/940848
  1296. TEST_F(TransportClientSocketPoolTest, SpdyAuthOneConnectJobTwoRequests) {
  1297. const url::SchemeHostPort kEndpoint(url::kHttpsScheme,
  1298. "unresolvable.host.name", 443);
  1299. const HostPortPair kProxy("unresolvable.proxy.name", 443);
  1300. session_deps_.host_resolver->set_synchronous_mode(true);
  1301. // Create a socket pool which only allows a single connection at a time.
  1302. TransportClientSocketPool pool(
  1303. 1, 1, kUnusedIdleSocketTimeout,
  1304. ProxyUriToProxyServer("https://unresolvable.proxy.name",
  1305. ProxyServer::SCHEME_HTTP /* default_scheme */),
  1306. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1307. SpdyTestUtil spdy_util;
  1308. spdy::SpdySerializedFrame connect(spdy_util.ConstructSpdyConnect(
  1309. nullptr, 0, 1, HttpProxyConnectJob::kH2QuicTunnelPriority,
  1310. HostPortPair::FromSchemeHostPort(kEndpoint)));
  1311. MockWrite writes[] = {
  1312. CreateMockWrite(connect, 0, ASYNC),
  1313. MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 4),
  1314. };
  1315. // The proxy responds to the connect with a 407, and them an
  1316. // ERROR_CODE_HTTP_1_1_REQUIRED.
  1317. const char kAuthStatus[] = "407";
  1318. const char* const kAuthChallenge[] = {
  1319. "proxy-authenticate",
  1320. "NTLM",
  1321. };
  1322. spdy::SpdySerializedFrame connect_auth_resp(spdy_util.ConstructSpdyReplyError(
  1323. kAuthStatus, kAuthChallenge, std::size(kAuthChallenge) / 2, 1));
  1324. spdy::SpdySerializedFrame reset(
  1325. spdy_util.ConstructSpdyRstStream(1, spdy::ERROR_CODE_HTTP_1_1_REQUIRED));
  1326. MockRead reads[] = {
  1327. CreateMockRead(connect_auth_resp, 1, ASYNC),
  1328. CreateMockRead(reset, 2, SYNCHRONOUS),
  1329. MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3),
  1330. };
  1331. SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
  1332. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
  1333. SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
  1334. ssl_data.next_proto = kProtoHTTP2;
  1335. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
  1336. // Second connection fails, and gets a different error. Not a vital part of
  1337. // this test, but allows waiting for the second request to complete without
  1338. // too much extra code.
  1339. SequencedSocketData socket_data2(
  1340. MockConnect(SYNCHRONOUS, ERR_CONNECTION_TIMED_OUT),
  1341. base::span<const MockRead>(), base::span<const MockWrite>());
  1342. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data2);
  1343. SSLSocketDataProvider ssl_data2(SYNCHRONOUS, OK);
  1344. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data2);
  1345. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  1346. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1347. std::make_unique<SSLConfig>() /* ssl_config_for_origin */,
  1348. std::make_unique<SSLConfig>() /* ssl_config_for_proxy */);
  1349. ClientSocketPool::GroupId group_id(
  1350. kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1351. SecureDnsPolicy::kAllow);
  1352. // Start the first connection attempt.
  1353. TestCompletionCallback callback1;
  1354. ClientSocketHandle handle1;
  1355. base::RunLoop run_loop;
  1356. int rv1 = handle1.Init(group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS,
  1357. HIGHEST, SocketTag(),
  1358. ClientSocketPool::RespectLimits::ENABLED,
  1359. callback1.callback(),
  1360. base::BindLambdaForTesting(
  1361. [&](const HttpResponseInfo& response,
  1362. HttpAuthController* auth_controller,
  1363. base::OnceClosure restart_with_auth_callback) {
  1364. run_loop.Quit();
  1365. }),
  1366. &pool, NetLogWithSource());
  1367. ASSERT_THAT(rv1, IsError(ERR_IO_PENDING));
  1368. // Create a second request with a lower priority.
  1369. TestCompletionCallback callback2;
  1370. ClientSocketHandle handle2;
  1371. int rv2 = handle2.Init(
  1372. group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOWEST,
  1373. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1374. callback2.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
  1375. NetLogWithSource());
  1376. ASSERT_THAT(rv2, IsError(ERR_IO_PENDING));
  1377. // The ConnectJob connection sees the auth challenge and HTTP2 error, which
  1378. // causes the SpdySession to be destroyed, as well as the SpdyStream. Then the
  1379. // ConnectJob is bound to the first request. Binding the request will result
  1380. // in temporarily assigning the ConnectJob to the second request, which
  1381. // results in an unneeded reprioritization, which should not dereference the
  1382. // null SpdyStream.
  1383. //
  1384. // TODO(mmenke): Avoid that temporary reassignment.
  1385. run_loop.Run();
  1386. // Just tear down everything without continuing - there are other tests for
  1387. // auth over HTTP2.
  1388. }
  1389. TEST_F(TransportClientSocketPoolTest, HttpTunnelSetupRedirect) {
  1390. const url::SchemeHostPort kEndpoint(url::kHttpsScheme, "host.test", 443);
  1391. const std::string kRedirectTarget = "https://some.other.host.test/";
  1392. const std::string kResponseText =
  1393. "HTTP/1.1 302 Found\r\n"
  1394. "Location: " +
  1395. kRedirectTarget +
  1396. "\r\n"
  1397. "Set-Cookie: foo=bar\r\n"
  1398. "\r\n";
  1399. for (IoMode io_mode : {SYNCHRONOUS, ASYNC}) {
  1400. SCOPED_TRACE(io_mode);
  1401. session_deps_.host_resolver->set_synchronous_mode(io_mode == SYNCHRONOUS);
  1402. for (bool use_https_proxy : {false, true}) {
  1403. SCOPED_TRACE(use_https_proxy);
  1404. TransportClientSocketPool proxy_pool(
  1405. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  1406. ProxyUriToProxyServer(
  1407. use_https_proxy ? "https://proxy.test" : "http://proxy.test",
  1408. ProxyServer::SCHEME_HTTP /* default_scheme */),
  1409. false /* is_for_websockets */,
  1410. tagging_common_connect_job_params_.get());
  1411. MockWrite writes[] = {
  1412. MockWrite(ASYNC, 0,
  1413. "CONNECT host.test:443 HTTP/1.1\r\n"
  1414. "Host: host.test:443\r\n"
  1415. "Proxy-Connection: keep-alive\r\n\r\n"),
  1416. };
  1417. MockRead reads[] = {
  1418. MockRead(ASYNC, 1, kResponseText.c_str()),
  1419. };
  1420. SequencedSocketData data(reads, writes);
  1421. tagging_client_socket_factory_.AddSocketDataProvider(&data);
  1422. SSLSocketDataProvider ssl(ASYNC, OK);
  1423. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl);
  1424. ClientSocketHandle handle;
  1425. TestCompletionCallback callback;
  1426. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  1427. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1428. std::make_unique<SSLConfig>() /* ssl_config_for_origin */,
  1429. std::make_unique<SSLConfig>() /* ssl_config_for_proxy */);
  1430. int rv = handle.Init(
  1431. ClientSocketPool::GroupId(
  1432. kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED,
  1433. NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  1434. socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1435. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  1436. ClientSocketPool::ProxyAuthCallback(), &proxy_pool,
  1437. NetLogWithSource());
  1438. rv = callback.GetResult(rv);
  1439. // We don't trust 302 responses to CONNECT.
  1440. EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
  1441. EXPECT_FALSE(handle.is_initialized());
  1442. }
  1443. }
  1444. }
  1445. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKey) {
  1446. const SchemefulSite kSite(GURL("https://foo.test/"));
  1447. const NetworkIsolationKey kNetworkIsolationKey(kSite, kSite);
  1448. const char kHost[] = "bar.test";
  1449. base::test::ScopedFeatureList scoped_feature_list;
  1450. scoped_feature_list.InitWithFeatures(
  1451. // enabled_features
  1452. {features::kPartitionConnectionsByNetworkIsolationKey,
  1453. features::kSplitHostCacheByNetworkIsolationKey},
  1454. // disabled_features
  1455. {});
  1456. session_deps_.host_resolver->set_ondemand_mode(true);
  1457. TransportClientSocketPool::GroupId group_id(
  1458. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1459. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey,
  1460. SecureDnsPolicy::kAllow);
  1461. ClientSocketHandle handle;
  1462. TestCompletionCallback callback;
  1463. EXPECT_THAT(
  1464. handle.Init(group_id,
  1465. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1466. nullptr /* ssl_config_for_origin */,
  1467. nullptr /* ssl_config_for_proxy */),
  1468. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1469. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  1470. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  1471. NetLogWithSource()),
  1472. IsError(ERR_IO_PENDING));
  1473. ASSERT_EQ(1u, session_deps_.host_resolver->last_id());
  1474. EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(1));
  1475. EXPECT_EQ(kNetworkIsolationKey,
  1476. session_deps_.host_resolver->request_network_isolation_key(1));
  1477. }
  1478. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySsl) {
  1479. const SchemefulSite kSite(GURL("https://foo.test/"));
  1480. const NetworkIsolationKey kNetworkIsolationKey(kSite, kSite);
  1481. const char kHost[] = "bar.test";
  1482. base::test::ScopedFeatureList scoped_feature_list;
  1483. scoped_feature_list.InitWithFeatures(
  1484. // enabled_features
  1485. {features::kPartitionConnectionsByNetworkIsolationKey,
  1486. features::kSplitHostCacheByNetworkIsolationKey},
  1487. // disabled_features
  1488. {});
  1489. session_deps_.host_resolver->set_ondemand_mode(true);
  1490. TransportClientSocketPool::GroupId group_id(
  1491. url::SchemeHostPort(url::kHttpsScheme, kHost, 443),
  1492. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey,
  1493. SecureDnsPolicy::kAllow);
  1494. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  1495. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  1496. ClientSocketHandle handle;
  1497. TestCompletionCallback callback;
  1498. EXPECT_THAT(
  1499. handle.Init(group_id,
  1500. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1501. std::move(ssl_config_for_origin),
  1502. /*ssl_config_for_proxy=*/nullptr),
  1503. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1504. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  1505. ClientSocketPool::ProxyAuthCallback(), pool_.get(),
  1506. NetLogWithSource()),
  1507. IsError(ERR_IO_PENDING));
  1508. ASSERT_EQ(1u, session_deps_.host_resolver->last_id());
  1509. EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(1));
  1510. EXPECT_EQ(kNetworkIsolationKey,
  1511. session_deps_.host_resolver->request_network_isolation_key(1));
  1512. }
  1513. // Test that, in the case of an HTTP proxy, the same transient
  1514. // NetworkIsolationKey is reused for resolving the proxy's host, regardless of
  1515. // input NIK.
  1516. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpProxy) {
  1517. const SchemefulSite kSite1(GURL("https://foo.test/"));
  1518. const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);
  1519. const SchemefulSite kSite2(GURL("https://bar.test/"));
  1520. const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
  1521. const char kHost[] = "bar.test";
  1522. const ProxyServer kProxyServer = ProxyUriToProxyServer(
  1523. "http://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
  1524. base::test::ScopedFeatureList scoped_feature_list;
  1525. scoped_feature_list.InitWithFeatures(
  1526. // enabled_features
  1527. {features::kPartitionConnectionsByNetworkIsolationKey,
  1528. features::kSplitHostCacheByNetworkIsolationKey},
  1529. // disabled_features
  1530. {});
  1531. session_deps_.host_resolver->set_ondemand_mode(true);
  1532. TransportClientSocketPool proxy_pool(
  1533. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyServer,
  1534. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1535. TransportClientSocketPool::GroupId group_id1(
  1536. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1537. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey1,
  1538. SecureDnsPolicy::kAllow);
  1539. ClientSocketHandle handle1;
  1540. TestCompletionCallback callback1;
  1541. EXPECT_THAT(
  1542. handle1.Init(group_id1,
  1543. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1544. nullptr /* ssl_config_for_origin */,
  1545. nullptr /* ssl_config_for_proxy */),
  1546. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1547. ClientSocketPool::RespectLimits::ENABLED,
  1548. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1549. &proxy_pool, NetLogWithSource()),
  1550. IsError(ERR_IO_PENDING));
  1551. TransportClientSocketPool::GroupId group_id2(
  1552. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1553. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey2,
  1554. SecureDnsPolicy::kAllow);
  1555. ClientSocketHandle handle2;
  1556. TestCompletionCallback callback2;
  1557. EXPECT_THAT(
  1558. handle2.Init(group_id2,
  1559. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1560. nullptr /* ssl_config_for_origin */,
  1561. nullptr /* ssl_config_for_proxy */),
  1562. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1563. ClientSocketPool::RespectLimits::ENABLED,
  1564. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1565. &proxy_pool, NetLogWithSource()),
  1566. IsError(ERR_IO_PENDING));
  1567. ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
  1568. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1569. session_deps_.host_resolver->request_host(1));
  1570. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1571. session_deps_.host_resolver->request_host(2));
  1572. EXPECT_TRUE(session_deps_.host_resolver->request_network_isolation_key(1)
  1573. .IsTransient());
  1574. EXPECT_EQ(session_deps_.host_resolver->request_network_isolation_key(1),
  1575. session_deps_.host_resolver->request_network_isolation_key(2));
  1576. }
  1577. // Test that, in the case of an HTTPS proxy, the same transient
  1578. // NetworkIsolationKey is reused for resolving the proxy's host, regardless of
  1579. // input NIK.
  1580. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpsProxy) {
  1581. const SchemefulSite kSite1(GURL("https://foo.test/"));
  1582. const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);
  1583. const SchemefulSite kSite2(GURL("https://bar.test/"));
  1584. const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
  1585. const char kHost[] = "bar.test";
  1586. const ProxyServer kProxyServer = ProxyUriToProxyServer(
  1587. "https://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
  1588. base::test::ScopedFeatureList scoped_feature_list;
  1589. scoped_feature_list.InitWithFeatures(
  1590. // enabled_features
  1591. {features::kPartitionConnectionsByNetworkIsolationKey,
  1592. features::kSplitHostCacheByNetworkIsolationKey},
  1593. // disabled_features
  1594. {});
  1595. session_deps_.host_resolver->set_ondemand_mode(true);
  1596. TransportClientSocketPool proxy_pool(
  1597. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyServer,
  1598. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1599. TransportClientSocketPool::GroupId group_id1(
  1600. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1601. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey1,
  1602. SecureDnsPolicy::kAllow);
  1603. ClientSocketHandle handle1;
  1604. TestCompletionCallback callback1;
  1605. EXPECT_THAT(handle1.Init(
  1606. group_id1,
  1607. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1608. nullptr /* ssl_config_for_origin */,
  1609. std::make_unique<SSLConfig>() /* ssl_config_for_proxy */),
  1610. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1611. ClientSocketPool::RespectLimits::ENABLED,
  1612. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1613. &proxy_pool, NetLogWithSource()),
  1614. IsError(ERR_IO_PENDING));
  1615. TransportClientSocketPool::GroupId group_id2(
  1616. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1617. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey2,
  1618. SecureDnsPolicy::kAllow);
  1619. ClientSocketHandle handle2;
  1620. TestCompletionCallback callback2;
  1621. EXPECT_THAT(handle2.Init(
  1622. group_id2,
  1623. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1624. nullptr /* ssl_config_for_origin */,
  1625. std::make_unique<SSLConfig>() /* ssl_config_for_proxy */),
  1626. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1627. ClientSocketPool::RespectLimits::ENABLED,
  1628. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  1629. &proxy_pool, NetLogWithSource()),
  1630. IsError(ERR_IO_PENDING));
  1631. ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
  1632. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1633. session_deps_.host_resolver->request_host(1));
  1634. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1635. session_deps_.host_resolver->request_host(2));
  1636. EXPECT_TRUE(session_deps_.host_resolver->request_network_isolation_key(1)
  1637. .IsTransient());
  1638. EXPECT_EQ(session_deps_.host_resolver->request_network_isolation_key(1),
  1639. session_deps_.host_resolver->request_network_isolation_key(2));
  1640. }
  1641. // Test that, in the case of a SOCKS5 proxy, the passed in NetworkIsolationKey
  1642. // is used for the destination DNS lookup, and the same transient
  1643. // NetworkIsolationKey is reused for resolving the proxy's host, regardless of
  1644. // input NIK.
  1645. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks4Proxy) {
  1646. const SchemefulSite kSite1(GURL("https://foo.test/"));
  1647. const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);
  1648. const SchemefulSite kSite2(GURL("https://bar.test/"));
  1649. const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
  1650. const char kHost[] = "bar.test";
  1651. const ProxyServer kProxyServer = ProxyUriToProxyServer(
  1652. "socks4://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
  1653. base::test::ScopedFeatureList scoped_feature_list;
  1654. scoped_feature_list.InitWithFeatures(
  1655. // enabled_features
  1656. {features::kPartitionConnectionsByNetworkIsolationKey,
  1657. features::kSplitHostCacheByNetworkIsolationKey},
  1658. // disabled_features
  1659. {});
  1660. session_deps_.host_resolver->set_ondemand_mode(true);
  1661. // Test will establish two connections, but never use them to transfer data,
  1662. // since thet stall on the followup DNS lookups.
  1663. StaticSocketDataProvider data1;
  1664. data1.set_connect_data(MockConnect(SYNCHRONOUS, OK));
  1665. tagging_client_socket_factory_.AddSocketDataProvider(&data1);
  1666. StaticSocketDataProvider data2;
  1667. data2.set_connect_data(MockConnect(SYNCHRONOUS, OK));
  1668. tagging_client_socket_factory_.AddSocketDataProvider(&data2);
  1669. TransportClientSocketPool proxy_pool(
  1670. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyServer,
  1671. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1672. TransportClientSocketPool::GroupId group_id1(
  1673. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1674. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey1,
  1675. SecureDnsPolicy::kAllow);
  1676. ClientSocketHandle handle1;
  1677. TestCompletionCallback callback1;
  1678. EXPECT_THAT(
  1679. handle1.Init(group_id1,
  1680. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1681. nullptr /* ssl_config_for_origin */,
  1682. nullptr /* ssl_config_for_proxy */),
  1683. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1684. ClientSocketPool::RespectLimits::ENABLED,
  1685. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1686. &proxy_pool, NetLogWithSource()),
  1687. IsError(ERR_IO_PENDING));
  1688. TransportClientSocketPool::GroupId group_id2(
  1689. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1690. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey2,
  1691. SecureDnsPolicy::kAllow);
  1692. ClientSocketHandle handle2;
  1693. TestCompletionCallback callback2;
  1694. EXPECT_THAT(
  1695. handle2.Init(group_id2,
  1696. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1697. nullptr /* ssl_config_for_origin */,
  1698. nullptr /* ssl_config_for_proxy */),
  1699. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1700. ClientSocketPool::RespectLimits::ENABLED,
  1701. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  1702. &proxy_pool, NetLogWithSource()),
  1703. IsError(ERR_IO_PENDING));
  1704. // First two lookups are for the proxy's hostname, and should use the same
  1705. // transient NIK.
  1706. ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
  1707. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1708. session_deps_.host_resolver->request_host(1));
  1709. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1710. session_deps_.host_resolver->request_host(2));
  1711. EXPECT_TRUE(session_deps_.host_resolver->request_network_isolation_key(1)
  1712. .IsTransient());
  1713. EXPECT_EQ(session_deps_.host_resolver->request_network_isolation_key(1),
  1714. session_deps_.host_resolver->request_network_isolation_key(2));
  1715. // First two lookups completes, starting the next two, which should be for the
  1716. // destination's hostname, and should use the passed in NIKs.
  1717. session_deps_.host_resolver->ResolveNow(1);
  1718. session_deps_.host_resolver->ResolveNow(2);
  1719. ASSERT_EQ(4u, session_deps_.host_resolver->last_id());
  1720. EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(3));
  1721. EXPECT_EQ(kNetworkIsolationKey1,
  1722. session_deps_.host_resolver->request_network_isolation_key(3));
  1723. EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(4));
  1724. EXPECT_EQ(kNetworkIsolationKey2,
  1725. session_deps_.host_resolver->request_network_isolation_key(4));
  1726. }
  1727. // Test that, in the case of a SOCKS5 proxy, the same transient
  1728. // NetworkIsolationKey is reused for resolving the proxy's host, regardless of
  1729. // input NIK.
  1730. TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks5Proxy) {
  1731. const SchemefulSite kSite1(GURL("https://foo.test/"));
  1732. const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);
  1733. const SchemefulSite kSite2(GURL("https://bar.test/"));
  1734. const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
  1735. const char kHost[] = "bar.test";
  1736. const ProxyServer kProxyServer = ProxyUriToProxyServer(
  1737. "socks5://proxy.test", ProxyServer::SCHEME_HTTP /* default_scheme */);
  1738. base::test::ScopedFeatureList scoped_feature_list;
  1739. scoped_feature_list.InitWithFeatures(
  1740. // enabled_features
  1741. {features::kPartitionConnectionsByNetworkIsolationKey,
  1742. features::kSplitHostCacheByNetworkIsolationKey},
  1743. // disabled_features
  1744. {});
  1745. session_deps_.host_resolver->set_ondemand_mode(true);
  1746. TransportClientSocketPool proxy_pool(
  1747. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyServer,
  1748. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1749. TransportClientSocketPool::GroupId group_id1(
  1750. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1751. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey1,
  1752. SecureDnsPolicy::kAllow);
  1753. ClientSocketHandle handle1;
  1754. TestCompletionCallback callback1;
  1755. EXPECT_THAT(
  1756. handle1.Init(group_id1,
  1757. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1758. nullptr /* ssl_config_for_origin */,
  1759. nullptr /* ssl_config_for_proxy */),
  1760. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1761. ClientSocketPool::RespectLimits::ENABLED,
  1762. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1763. &proxy_pool, NetLogWithSource()),
  1764. IsError(ERR_IO_PENDING));
  1765. TransportClientSocketPool::GroupId group_id2(
  1766. url::SchemeHostPort(url::kHttpScheme, kHost, 80),
  1767. PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkIsolationKey2,
  1768. SecureDnsPolicy::kAllow);
  1769. ClientSocketHandle handle2;
  1770. TestCompletionCallback callback2;
  1771. EXPECT_THAT(
  1772. handle2.Init(group_id2,
  1773. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1774. nullptr /* ssl_config_for_origin */,
  1775. nullptr /* ssl_config_for_proxy */),
  1776. TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
  1777. ClientSocketPool::RespectLimits::ENABLED,
  1778. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  1779. &proxy_pool, NetLogWithSource()),
  1780. IsError(ERR_IO_PENDING));
  1781. ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
  1782. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1783. session_deps_.host_resolver->request_host(1));
  1784. EXPECT_EQ(kProxyServer.host_port_pair().host(),
  1785. session_deps_.host_resolver->request_host(2));
  1786. EXPECT_TRUE(session_deps_.host_resolver->request_network_isolation_key(1)
  1787. .IsTransient());
  1788. EXPECT_EQ(session_deps_.host_resolver->request_network_isolation_key(1),
  1789. session_deps_.host_resolver->request_network_isolation_key(2));
  1790. }
  1791. TEST_F(TransportClientSocketPoolTest, HasActiveSocket) {
  1792. const url::SchemeHostPort kEndpoint1(url::kHttpScheme, "host1.test", 80);
  1793. const url::SchemeHostPort kEndpoint2(url::kHttpScheme, "host2.test", 80);
  1794. ClientSocketHandle handle;
  1795. ClientSocketPool::GroupId group_id1(
  1796. kEndpoint1, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1797. SecureDnsPolicy::kAllow);
  1798. ClientSocketPool::GroupId group_id2(
  1799. kEndpoint2, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1800. SecureDnsPolicy::kAllow);
  1801. // HasActiveSocket() must return false before creating a socket.
  1802. EXPECT_FALSE(pool_->HasActiveSocket(group_id1));
  1803. TestCompletionCallback callback1;
  1804. int rv1 =
  1805. handle.Init(group_id1, params_, absl::nullopt /* proxy_annotation_tag */,
  1806. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1807. callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
  1808. pool_.get(), NetLogWithSource());
  1809. EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
  1810. // HasActiveSocket() must return true while connecting.
  1811. EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
  1812. EXPECT_FALSE(handle.is_initialized());
  1813. EXPECT_FALSE(handle.socket());
  1814. EXPECT_THAT(callback1.WaitForResult(), IsOk());
  1815. // HasActiveSocket() must return true after handed out.
  1816. EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
  1817. EXPECT_TRUE(handle.is_initialized());
  1818. EXPECT_TRUE(handle.socket());
  1819. handle.Reset();
  1820. // HasActiveSocket returns true for the idle socket.
  1821. EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
  1822. // Now we should have 1 idle socket.
  1823. EXPECT_EQ(1, pool_->IdleSocketCount());
  1824. // HasActiveSocket() for group_id2 must still return false.
  1825. EXPECT_FALSE(pool_->HasActiveSocket(group_id2));
  1826. TestCompletionCallback callback2;
  1827. int rv2 =
  1828. handle.Init(group_id2, params_, absl::nullopt /* proxy_annotation_tag */,
  1829. LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1830. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  1831. pool_.get(), NetLogWithSource());
  1832. EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
  1833. // HasActiveSocket(group_id2) must return true while connecting.
  1834. EXPECT_TRUE(pool_->HasActiveSocket(group_id2));
  1835. // HasActiveSocket(group_id1) must still return true.
  1836. EXPECT_TRUE(pool_->HasActiveSocket(group_id2));
  1837. // Close the sockets.
  1838. pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
  1839. // HasActiveSocket() must return false after closing the socket.
  1840. EXPECT_FALSE(pool_->HasActiveSocket(group_id1));
  1841. EXPECT_FALSE(pool_->HasActiveSocket(group_id2));
  1842. }
  1843. // Test that SocketTag passed into TransportClientSocketPool is applied to
  1844. // returned sockets.
  1845. #if BUILDFLAG(IS_ANDROID)
  1846. TEST_F(TransportClientSocketPoolTest, Tag) {
  1847. if (!CanGetTaggedBytes()) {
  1848. DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
  1849. return;
  1850. }
  1851. // Start test server.
  1852. EmbeddedTestServer test_server;
  1853. test_server.AddDefaultHandlers(base::FilePath());
  1854. ASSERT_TRUE(test_server.Start());
  1855. ClientSocketHandle handle;
  1856. int32_t tag_val1 = 0x12345678;
  1857. SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
  1858. int32_t tag_val2 = 0x87654321;
  1859. SocketTag tag2(getuid(), tag_val2);
  1860. // Test socket is tagged before connected.
  1861. uint64_t old_traffic = GetTaggedBytes(tag_val1);
  1862. const ClientSocketPool::GroupId kGroupId(
  1863. url::SchemeHostPort(test_server.base_url()),
  1864. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1865. SecureDnsPolicy::kAllow);
  1866. scoped_refptr<ClientSocketPool::SocketParams> params =
  1867. ClientSocketPool::SocketParams::CreateForHttpForTesting();
  1868. TestCompletionCallback callback;
  1869. int rv =
  1870. handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1871. LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
  1872. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1873. pool_for_real_sockets_.get(), NetLogWithSource());
  1874. EXPECT_THAT(callback.GetResult(rv), IsOk());
  1875. EXPECT_TRUE(handle.socket());
  1876. EXPECT_TRUE(handle.socket()->IsConnected());
  1877. EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
  1878. // Test reused socket is retagged.
  1879. StreamSocket* socket = handle.socket();
  1880. handle.Reset();
  1881. old_traffic = GetTaggedBytes(tag_val2);
  1882. rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1883. LOW, tag2, ClientSocketPool::RespectLimits::ENABLED,
  1884. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1885. pool_for_real_sockets_.get(), NetLogWithSource());
  1886. EXPECT_THAT(rv, IsOk());
  1887. EXPECT_TRUE(handle.socket());
  1888. EXPECT_TRUE(handle.socket()->IsConnected());
  1889. EXPECT_EQ(handle.socket(), socket);
  1890. const char kRequest[] = "GET / HTTP/1.0\n\n";
  1891. scoped_refptr<IOBuffer> write_buffer =
  1892. base::MakeRefCounted<StringIOBuffer>(kRequest);
  1893. rv =
  1894. handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  1895. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  1896. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  1897. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  1898. // Disconnect socket to prevent reuse.
  1899. handle.socket()->Disconnect();
  1900. handle.Reset();
  1901. // Test connect jobs that are orphaned and then adopted, appropriately apply
  1902. // new tag. Request socket with |tag1|.
  1903. TestCompletionCallback callback2;
  1904. rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1905. LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
  1906. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  1907. pool_for_real_sockets_.get(), NetLogWithSource());
  1908. EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
  1909. // Abort and request socket with |tag2|.
  1910. handle.Reset();
  1911. rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1912. LOW, tag2, ClientSocketPool::RespectLimits::ENABLED,
  1913. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1914. pool_for_real_sockets_.get(), NetLogWithSource());
  1915. EXPECT_THAT(callback.GetResult(rv), IsOk());
  1916. EXPECT_TRUE(handle.socket());
  1917. EXPECT_TRUE(handle.socket()->IsConnected());
  1918. // Verify socket has |tag2| applied.
  1919. old_traffic = GetTaggedBytes(tag_val2);
  1920. rv =
  1921. handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  1922. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  1923. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  1924. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  1925. // Disconnect socket to prevent reuse.
  1926. handle.socket()->Disconnect();
  1927. handle.Reset();
  1928. // Eat the left over connect job from the second request.
  1929. // TODO(pauljensen): remove when crbug.com/800731 fixed.
  1930. rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1931. LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
  1932. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1933. pool_for_real_sockets_.get(), NetLogWithSource());
  1934. EXPECT_THAT(rv, IsOk());
  1935. // Disconnect socket to prevent reuse.
  1936. handle.socket()->Disconnect();
  1937. handle.Reset();
  1938. // Test two connect jobs of differing priorities. Start the lower priority one
  1939. // first but expect its socket to get vended to the higher priority request.
  1940. ClientSocketHandle handle_high_pri;
  1941. TestCompletionCallback callback_high_pri;
  1942. rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
  1943. LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
  1944. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1945. pool_for_real_sockets_.get(), NetLogWithSource());
  1946. EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
  1947. int rv_high_pri = handle_high_pri.Init(
  1948. kGroupId, params, absl::nullopt /* proxy_annotation_tag */, HIGHEST, tag2,
  1949. ClientSocketPool::RespectLimits::ENABLED, callback_high_pri.callback(),
  1950. ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
  1951. NetLogWithSource());
  1952. EXPECT_THAT(callback_high_pri.GetResult(rv_high_pri), IsOk());
  1953. EXPECT_TRUE(handle_high_pri.socket());
  1954. EXPECT_TRUE(handle_high_pri.socket()->IsConnected());
  1955. EXPECT_THAT(callback.GetResult(rv), IsOk());
  1956. EXPECT_TRUE(handle.socket());
  1957. EXPECT_TRUE(handle.socket()->IsConnected());
  1958. // Verify |handle_high_pri| has |tag2| applied.
  1959. old_traffic = GetTaggedBytes(tag_val2);
  1960. rv = handle_high_pri.socket()->Write(write_buffer.get(), strlen(kRequest),
  1961. callback.callback(),
  1962. TRAFFIC_ANNOTATION_FOR_TESTS);
  1963. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  1964. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  1965. // Verify |handle| has |tag1| applied.
  1966. old_traffic = GetTaggedBytes(tag_val1);
  1967. rv =
  1968. handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  1969. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  1970. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  1971. EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
  1972. }
  1973. TEST_F(TransportClientSocketPoolTest, TagSOCKSProxy) {
  1974. session_deps_.host_resolver->set_synchronous_mode(true);
  1975. TransportClientSocketPool proxy_pool(
  1976. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  1977. ProxyUriToProxyServer("socks5://proxy",
  1978. ProxyServer::SCHEME_HTTP /* default_scheme */),
  1979. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  1980. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  1981. SocketTag tag2(getuid(), 0x87654321);
  1982. const url::SchemeHostPort kDestination(url::kHttpScheme, "host", 80);
  1983. const ClientSocketPool::GroupId kGroupId(
  1984. kDestination, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1985. SecureDnsPolicy::kAllow);
  1986. scoped_refptr<ClientSocketPool::SocketParams> socks_params =
  1987. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1988. nullptr /* ssl_config_for_origin */,
  1989. nullptr /* ssl_config_for_proxy */);
  1990. // Test socket is tagged when created synchronously.
  1991. SOCKS5MockData data_sync(SYNCHRONOUS);
  1992. data_sync.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
  1993. tagging_client_socket_factory_.AddSocketDataProvider(
  1994. data_sync.data_provider());
  1995. ClientSocketHandle handle;
  1996. int rv = handle.Init(
  1997. kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
  1998. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  1999. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2000. EXPECT_THAT(rv, IsOk());
  2001. EXPECT_TRUE(handle.is_initialized());
  2002. EXPECT_TRUE(handle.socket());
  2003. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2004. tag1);
  2005. EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
  2006. ->tagged_before_connected());
  2007. // Test socket is tagged when reused synchronously.
  2008. StreamSocket* socket = handle.socket();
  2009. handle.Reset();
  2010. rv = handle.Init(
  2011. kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
  2012. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2013. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2014. EXPECT_THAT(rv, IsOk());
  2015. EXPECT_TRUE(handle.socket());
  2016. EXPECT_TRUE(handle.socket()->IsConnected());
  2017. EXPECT_EQ(handle.socket(), socket);
  2018. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2019. tag2);
  2020. handle.socket()->Disconnect();
  2021. handle.Reset();
  2022. // Test socket is tagged when created asynchronously.
  2023. SOCKS5MockData data_async(ASYNC);
  2024. tagging_client_socket_factory_.AddSocketDataProvider(
  2025. data_async.data_provider());
  2026. TestCompletionCallback callback;
  2027. rv = handle.Init(kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW,
  2028. tag1, ClientSocketPool::RespectLimits::ENABLED,
  2029. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  2030. &proxy_pool, NetLogWithSource());
  2031. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  2032. EXPECT_THAT(callback.WaitForResult(), IsOk());
  2033. EXPECT_TRUE(handle.is_initialized());
  2034. EXPECT_TRUE(handle.socket());
  2035. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2036. tag1);
  2037. EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
  2038. ->tagged_before_connected());
  2039. // Test socket is tagged when reused after being created asynchronously.
  2040. socket = handle.socket();
  2041. handle.Reset();
  2042. rv = handle.Init(
  2043. kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
  2044. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2045. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2046. EXPECT_THAT(rv, IsOk());
  2047. EXPECT_TRUE(handle.socket());
  2048. EXPECT_TRUE(handle.socket()->IsConnected());
  2049. EXPECT_EQ(handle.socket(), socket);
  2050. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2051. tag2);
  2052. }
  2053. TEST_F(TransportClientSocketPoolTest, TagSSLDirect) {
  2054. if (!CanGetTaggedBytes()) {
  2055. DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
  2056. return;
  2057. }
  2058. // Start test server.
  2059. EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2060. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
  2061. test_server.AddDefaultHandlers(base::FilePath());
  2062. ASSERT_TRUE(test_server.Start());
  2063. TestCompletionCallback callback;
  2064. ClientSocketHandle handle;
  2065. int32_t tag_val1 = 0x12345678;
  2066. SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
  2067. int32_t tag_val2 = 0x87654321;
  2068. SocketTag tag2(getuid(), tag_val2);
  2069. const ClientSocketPool::GroupId kGroupId(
  2070. url::SchemeHostPort(test_server.base_url()),
  2071. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  2072. SecureDnsPolicy::kAllow);
  2073. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  2074. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  2075. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2076. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2077. std::move(ssl_config_for_origin),
  2078. /*ssl_config_for_proxy=*/nullptr);
  2079. // Test socket is tagged before connected.
  2080. uint64_t old_traffic = GetTaggedBytes(tag_val1);
  2081. int rv = handle.Init(
  2082. kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
  2083. tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  2084. ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
  2085. NetLogWithSource());
  2086. EXPECT_THAT(callback.GetResult(rv), IsOk());
  2087. EXPECT_TRUE(handle.socket());
  2088. EXPECT_TRUE(handle.socket()->IsConnected());
  2089. EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
  2090. // Test reused socket is retagged.
  2091. StreamSocket* socket = handle.socket();
  2092. handle.Reset();
  2093. old_traffic = GetTaggedBytes(tag_val2);
  2094. TestCompletionCallback callback2;
  2095. rv = handle.Init(kGroupId, socket_params,
  2096. absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
  2097. ClientSocketPool::RespectLimits::ENABLED,
  2098. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  2099. pool_for_real_sockets_.get(), NetLogWithSource());
  2100. EXPECT_THAT(rv, IsOk());
  2101. EXPECT_TRUE(handle.socket());
  2102. EXPECT_TRUE(handle.socket()->IsConnected());
  2103. EXPECT_EQ(handle.socket(), socket);
  2104. const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
  2105. scoped_refptr<IOBuffer> write_buffer =
  2106. base::MakeRefCounted<StringIOBuffer>(kRequest);
  2107. rv =
  2108. handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  2109. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  2110. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  2111. scoped_refptr<IOBufferWithSize> read_buffer =
  2112. base::MakeRefCounted<IOBufferWithSize>(1);
  2113. rv = handle.socket()->Read(read_buffer.get(), read_buffer->size(),
  2114. callback.callback());
  2115. EXPECT_EQ(read_buffer->size(), callback.GetResult(rv));
  2116. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  2117. // Disconnect socket to prevent reuse.
  2118. handle.socket()->Disconnect();
  2119. handle.Reset();
  2120. }
  2121. TEST_F(TransportClientSocketPoolTest, TagSSLDirectTwoSockets) {
  2122. if (!CanGetTaggedBytes()) {
  2123. DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
  2124. return;
  2125. }
  2126. // Start test server.
  2127. EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2128. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
  2129. test_server.AddDefaultHandlers(base::FilePath());
  2130. ASSERT_TRUE(test_server.Start());
  2131. ClientSocketHandle handle;
  2132. int32_t tag_val1 = 0x12345678;
  2133. SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
  2134. int32_t tag_val2 = 0x87654321;
  2135. SocketTag tag2(getuid(), tag_val2);
  2136. const ClientSocketPool::GroupId kGroupId(
  2137. url::SchemeHostPort(test_server.base_url()),
  2138. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  2139. SecureDnsPolicy::kAllow);
  2140. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  2141. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  2142. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2143. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2144. std::move(ssl_config_for_origin),
  2145. /*ssl_config_for_proxy=*/nullptr);
  2146. // Test connect jobs that are orphaned and then adopted, appropriately apply
  2147. // new tag. Request socket with |tag1|.
  2148. TestCompletionCallback callback;
  2149. int rv = handle.Init(
  2150. kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
  2151. tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  2152. ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
  2153. NetLogWithSource());
  2154. EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
  2155. // Abort and request socket with |tag2|.
  2156. handle.Reset();
  2157. TestCompletionCallback callback2;
  2158. rv = handle.Init(kGroupId, socket_params,
  2159. absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
  2160. ClientSocketPool::RespectLimits::ENABLED,
  2161. callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
  2162. pool_for_real_sockets_.get(), NetLogWithSource());
  2163. EXPECT_THAT(callback2.GetResult(rv), IsOk());
  2164. EXPECT_TRUE(handle.socket());
  2165. EXPECT_TRUE(handle.socket()->IsConnected());
  2166. // Verify socket has |tag2| applied.
  2167. uint64_t old_traffic = GetTaggedBytes(tag_val2);
  2168. const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
  2169. scoped_refptr<IOBuffer> write_buffer =
  2170. base::MakeRefCounted<StringIOBuffer>(kRequest);
  2171. rv = handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  2172. callback2.callback(),
  2173. TRAFFIC_ANNOTATION_FOR_TESTS);
  2174. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback2.GetResult(rv));
  2175. scoped_refptr<IOBufferWithSize> read_buffer =
  2176. base::MakeRefCounted<IOBufferWithSize>(1);
  2177. rv = handle.socket()->Read(read_buffer.get(), read_buffer->size(),
  2178. callback2.callback());
  2179. EXPECT_EQ(read_buffer->size(), callback2.GetResult(rv));
  2180. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  2181. }
  2182. TEST_F(TransportClientSocketPoolTest, TagSSLDirectTwoSocketsFullPool) {
  2183. if (!CanGetTaggedBytes()) {
  2184. DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
  2185. return;
  2186. }
  2187. // Start test server.
  2188. EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2189. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
  2190. test_server.AddDefaultHandlers(base::FilePath());
  2191. ASSERT_TRUE(test_server.Start());
  2192. TestCompletionCallback callback;
  2193. ClientSocketHandle handle;
  2194. int32_t tag_val1 = 0x12345678;
  2195. SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
  2196. int32_t tag_val2 = 0x87654321;
  2197. SocketTag tag2(getuid(), tag_val2);
  2198. const ClientSocketPool::GroupId kGroupId(
  2199. url::SchemeHostPort(test_server.base_url()),
  2200. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  2201. SecureDnsPolicy::kAllow);
  2202. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  2203. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  2204. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2205. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2206. std::move(ssl_config_for_origin),
  2207. /*ssl_config_for_proxy=*/nullptr);
  2208. // Test that sockets paused by a full underlying socket pool are properly
  2209. // connected and tagged when underlying pool is freed up.
  2210. // Fill up all slots in TCP pool.
  2211. ClientSocketHandle tcp_handles[kMaxSocketsPerGroup];
  2212. int rv;
  2213. for (auto& tcp_handle : tcp_handles) {
  2214. rv = tcp_handle.Init(
  2215. kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
  2216. tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  2217. ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
  2218. NetLogWithSource());
  2219. EXPECT_THAT(callback.GetResult(rv), IsOk());
  2220. EXPECT_TRUE(tcp_handle.socket());
  2221. EXPECT_TRUE(tcp_handle.socket()->IsConnected());
  2222. }
  2223. // Request two SSL sockets.
  2224. ClientSocketHandle handle_to_be_canceled;
  2225. rv = handle_to_be_canceled.Init(
  2226. kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
  2227. tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  2228. ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
  2229. NetLogWithSource());
  2230. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  2231. rv = handle.Init(kGroupId, socket_params,
  2232. absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
  2233. ClientSocketPool::RespectLimits::ENABLED,
  2234. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  2235. pool_for_real_sockets_.get(), NetLogWithSource());
  2236. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  2237. // Cancel first request.
  2238. handle_to_be_canceled.Reset();
  2239. // Disconnect a TCP socket to free up a slot.
  2240. tcp_handles[0].socket()->Disconnect();
  2241. tcp_handles[0].Reset();
  2242. // Verify |handle| gets a valid tagged socket.
  2243. EXPECT_THAT(callback.WaitForResult(), IsOk());
  2244. EXPECT_TRUE(handle.socket());
  2245. EXPECT_TRUE(handle.socket()->IsConnected());
  2246. uint64_t old_traffic = GetTaggedBytes(tag_val2);
  2247. const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
  2248. scoped_refptr<IOBuffer> write_buffer =
  2249. base::MakeRefCounted<StringIOBuffer>(kRequest);
  2250. rv =
  2251. handle.socket()->Write(write_buffer.get(), strlen(kRequest),
  2252. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  2253. EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
  2254. scoped_refptr<IOBufferWithSize> read_buffer =
  2255. base::MakeRefCounted<IOBufferWithSize>(1);
  2256. EXPECT_EQ(handle.socket()->Read(read_buffer.get(), read_buffer->size(),
  2257. callback.callback()),
  2258. ERR_IO_PENDING);
  2259. EXPECT_THAT(callback.WaitForResult(), read_buffer->size());
  2260. EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
  2261. }
  2262. TEST_F(TransportClientSocketPoolTest, TagHttpProxyNoTunnel) {
  2263. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  2264. SocketTag tag2(getuid(), 0x87654321);
  2265. TransportClientSocketPool proxy_pool(
  2266. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  2267. ProxyUriToProxyServer("http://proxy",
  2268. ProxyServer::SCHEME_HTTP /* default_scheme */),
  2269. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  2270. session_deps_.host_resolver->set_synchronous_mode(true);
  2271. SequencedSocketData socket_data;
  2272. socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
  2273. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
  2274. const url::SchemeHostPort kDestination(url::kHttpScheme, "www.google.com",
  2275. 80);
  2276. const ClientSocketPool::GroupId kGroupId(
  2277. kDestination, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  2278. SecureDnsPolicy::kAllow);
  2279. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2280. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2281. nullptr /* ssl_config_for_origin */,
  2282. nullptr /* ssl_config_for_proxy */);
  2283. // Verify requested socket is tagged properly.
  2284. ClientSocketHandle handle;
  2285. int rv = handle.Init(
  2286. kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
  2287. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2288. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2289. EXPECT_THAT(rv, IsOk());
  2290. EXPECT_TRUE(handle.is_initialized());
  2291. ASSERT_TRUE(handle.socket());
  2292. EXPECT_TRUE(handle.socket()->IsConnected());
  2293. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2294. tag1);
  2295. EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
  2296. ->tagged_before_connected());
  2297. // Verify reused socket is retagged properly.
  2298. StreamSocket* socket = handle.socket();
  2299. handle.Reset();
  2300. rv = handle.Init(
  2301. kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
  2302. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2303. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2304. EXPECT_THAT(rv, IsOk());
  2305. EXPECT_TRUE(handle.socket());
  2306. EXPECT_TRUE(handle.socket()->IsConnected());
  2307. EXPECT_EQ(handle.socket(), socket);
  2308. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2309. tag2);
  2310. handle.socket()->Disconnect();
  2311. handle.Reset();
  2312. }
  2313. // This creates a tunnel without SSL on top of it - something not normally done,
  2314. // though some non-HTTP consumers use this path to create tunnels for other
  2315. // uses.
  2316. TEST_F(TransportClientSocketPoolTest, TagHttpProxyTunnel) {
  2317. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  2318. SocketTag tag2(getuid(), 0x87654321);
  2319. TransportClientSocketPool proxy_pool(
  2320. kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
  2321. ProxyUriToProxyServer("http://proxy",
  2322. ProxyServer::SCHEME_HTTP /* default_scheme */),
  2323. false /* is_for_websockets */, tagging_common_connect_job_params_.get());
  2324. session_deps_.host_resolver->set_synchronous_mode(true);
  2325. std::string request =
  2326. "CONNECT www.google.com:443 HTTP/1.1\r\n"
  2327. "Host: www.google.com:443\r\n"
  2328. "Proxy-Connection: keep-alive\r\n\r\n";
  2329. MockWrite writes[] = {
  2330. MockWrite(SYNCHRONOUS, 0, request.c_str()),
  2331. };
  2332. MockRead reads[] = {
  2333. MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
  2334. };
  2335. SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
  2336. tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
  2337. SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
  2338. tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
  2339. const url::SchemeHostPort kDestination(url::kHttpsScheme, "www.google.com",
  2340. 443);
  2341. const ClientSocketPool::GroupId kGroupId(
  2342. kDestination, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  2343. SecureDnsPolicy::kAllow);
  2344. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  2345. ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
  2346. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2347. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2348. std::move(ssl_config_for_origin),
  2349. /*ssl_config_for_proxy=*/nullptr);
  2350. // Verify requested socket is tagged properly.
  2351. ClientSocketHandle handle;
  2352. int rv = handle.Init(
  2353. kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
  2354. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2355. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2356. EXPECT_THAT(rv, IsOk());
  2357. EXPECT_TRUE(handle.is_initialized());
  2358. ASSERT_TRUE(handle.socket());
  2359. EXPECT_TRUE(handle.socket()->IsConnected());
  2360. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2361. tag1);
  2362. EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
  2363. ->tagged_before_connected());
  2364. // Verify reused socket is retagged properly.
  2365. StreamSocket* socket = handle.socket();
  2366. handle.Reset();
  2367. rv = handle.Init(
  2368. kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
  2369. ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
  2370. ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
  2371. EXPECT_THAT(rv, IsOk());
  2372. EXPECT_TRUE(handle.socket());
  2373. EXPECT_TRUE(handle.socket()->IsConnected());
  2374. EXPECT_EQ(handle.socket(), socket);
  2375. EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
  2376. tag2);
  2377. handle.socket()->Disconnect();
  2378. handle.Reset();
  2379. }
  2380. #endif // BUILDFLAG(IS_ANDROID)
  2381. // Class that enables tests to set mock time.
  2382. class TransportClientSocketPoolMockNowSourceTest
  2383. : public TransportClientSocketPoolTest {
  2384. public:
  2385. TransportClientSocketPoolMockNowSourceTest(
  2386. const TransportClientSocketPoolMockNowSourceTest&) = delete;
  2387. TransportClientSocketPoolMockNowSourceTest& operator=(
  2388. const TransportClientSocketPoolMockNowSourceTest&) = delete;
  2389. protected:
  2390. TransportClientSocketPoolMockNowSourceTest()
  2391. : TransportClientSocketPoolTest(
  2392. base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  2393. };
  2394. // Tests that changing the idle unused socket timeout using the experiment
  2395. // works. The test first sets the value of timeout duration for idle sockets.
  2396. // Next, it opens |kNumIdleSockets| sockets. To trigger the cleanup of idle
  2397. // sockets that may have timedout, it then opens one more socket. This is
  2398. // required since requesting a new socket triggers cleanup of idle timedout
  2399. // sockets. Next, the test verifies the count of idle timed-out sockets.
  2400. TEST_F(TransportClientSocketPoolMockNowSourceTest, IdleUnusedSocketTimeout) {
  2401. const url::SchemeHostPort kSchemeHostPort1(url::kHttpScheme, "www.foo.com",
  2402. 80);
  2403. const url::SchemeHostPort kSchemeHostPort2(url::kHttpScheme, "www.bar.com",
  2404. 80);
  2405. const struct {
  2406. bool use_first_socket;
  2407. int fast_forward_seconds;
  2408. int unused_idle_socket_timeout_seconds;
  2409. bool expect_idle_socket;
  2410. } kTests[] = {
  2411. // When the clock is fast forwarded by a duration longer than
  2412. // |unused_idle_socket_timeout_seconds|, the first unused idle socket is
  2413. // expected to be timedout, and cleared.
  2414. {false, 0, 0, false},
  2415. {false, 9, 10, true},
  2416. {false, 11, 10, false},
  2417. {false, 19, 20, true},
  2418. {false, 21, 20, false},
  2419. // If |use_first_socket| is true, then the test would write some data to
  2420. // the socket, thereby marking it as "used". Thereafter, this idle socket
  2421. // should be timedout based on used idle socket timeout, and changing
  2422. // |unused_idle_socket_timeout_seconds| should not affect the
  2423. // |expected_idle_sockets|.
  2424. {true, 0, 0, true},
  2425. {true, 9, 10, true},
  2426. {true, 11, 10, true},
  2427. {true, 19, 20, true},
  2428. {true, 21, 20, true},
  2429. };
  2430. for (const auto& test : kTests) {
  2431. SpdySessionDependencies session_deps(
  2432. ConfiguredProxyResolutionService::CreateDirect());
  2433. std::unique_ptr<HttpNetworkSession> session(
  2434. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2435. base::test::ScopedFeatureList scoped_feature_list_;
  2436. std::map<std::string, std::string> parameters;
  2437. parameters["unused_idle_socket_timeout_seconds"] =
  2438. base::NumberToString(test.unused_idle_socket_timeout_seconds);
  2439. scoped_feature_list_.InitAndEnableFeatureWithParameters(
  2440. net::features::kNetUnusedIdleSocketTimeout, parameters);
  2441. const char kWriteData[] = "1";
  2442. const MockWrite kWrites[] = {MockWrite(SYNCHRONOUS, kWriteData)};
  2443. SequencedSocketData provider_socket_1(MockConnect(ASYNC, OK),
  2444. base::span<MockRead>(), kWrites);
  2445. {
  2446. // Create 1 socket.
  2447. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2448. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2449. nullptr /* ssl_config_for_origin */,
  2450. nullptr /* ssl_config_for_proxy */);
  2451. session_deps.socket_factory->AddSocketDataProvider(&provider_socket_1);
  2452. ClientSocketHandle connection;
  2453. TestCompletionCallback callback;
  2454. int rv = connection.Init(
  2455. ClientSocketPool::GroupId(
  2456. kSchemeHostPort1, PrivacyMode::PRIVACY_MODE_DISABLED,
  2457. NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  2458. ClientSocketPool::SocketParams::CreateForHttpForTesting(),
  2459. absl::nullopt /* proxy_annotation_tag */, MEDIUM, SocketTag(),
  2460. ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
  2461. ClientSocketPool::ProxyAuthCallback(),
  2462. session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  2463. ProxyServer::Direct()),
  2464. NetLogWithSource());
  2465. EXPECT_THAT(callback.GetResult(rv), IsOk());
  2466. EXPECT_FALSE(connection.socket()->WasEverUsed());
  2467. // Writing some data to the socket should set WasEverUsed.
  2468. if (test.use_first_socket) {
  2469. // Generate |socket_write_data| from kMockWriteData by appending null
  2470. // character to the latter.
  2471. auto write_buffer = base::MakeRefCounted<StringIOBuffer>(kWriteData);
  2472. TestCompletionCallback write_callback;
  2473. rv = connection.socket()->Write(
  2474. write_buffer.get(), write_buffer->size(), write_callback.callback(),
  2475. TRAFFIC_ANNOTATION_FOR_TESTS);
  2476. EXPECT_EQ(rv, 1);
  2477. EXPECT_TRUE(connection.socket()->WasEverUsed());
  2478. }
  2479. }
  2480. EXPECT_EQ(1, session
  2481. ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  2482. ProxyServer::Direct())
  2483. ->IdleSocketCount());
  2484. // Moving the clock forward may cause the idle socket to be timedout.
  2485. FastForwardBy(base::Seconds(test.fast_forward_seconds));
  2486. {
  2487. // Request a new socket to trigger cleanup of idle timedout sockets.
  2488. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  2489. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  2490. nullptr /* ssl_config_for_origin */,
  2491. nullptr /* ssl_config_for_proxy */);
  2492. SequencedSocketData provider_socket_2(MockConnect(ASYNC, OK),
  2493. base::span<MockRead>(),
  2494. base::span<MockWrite>());
  2495. session_deps.socket_factory->AddSocketDataProvider(&provider_socket_2);
  2496. ClientSocketHandle connection;
  2497. TestCompletionCallback callback;
  2498. int rv = connection.Init(
  2499. ClientSocketPool::GroupId(
  2500. kSchemeHostPort2, PrivacyMode::PRIVACY_MODE_DISABLED,
  2501. NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  2502. socket_params, absl::nullopt /* proxy_annotation_tag */, MEDIUM,
  2503. SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  2504. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  2505. session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  2506. ProxyServer::Direct()),
  2507. NetLogWithSource());
  2508. EXPECT_THAT(callback.GetResult(rv), IsOk());
  2509. connection.socket()->Disconnect();
  2510. }
  2511. EXPECT_EQ(test.expect_idle_socket ? 1 : 0,
  2512. session
  2513. ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  2514. ProxyServer::Direct())
  2515. ->IdleSocketCount());
  2516. }
  2517. }
  2518. } // namespace
  2519. } // namespace net