http_stream_factory_unittest.cc 153 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671
  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/http/http_stream_factory.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <set>
  8. #include <string>
  9. #include <tuple>
  10. #include <utility>
  11. #include <vector>
  12. #include "base/compiler_specific.h"
  13. #include "base/containers/contains.h"
  14. #include "base/memory/ptr_util.h"
  15. #include "base/no_destructor.h"
  16. #include "base/run_loop.h"
  17. #include "base/strings/strcat.h"
  18. #include "base/strings/string_piece.h"
  19. #include "base/test/metrics/histogram_tester.h"
  20. #include "base/test/scoped_feature_list.h"
  21. #include "build/build_config.h"
  22. #include "net/base/completion_once_callback.h"
  23. #include "net/base/features.h"
  24. #include "net/base/net_errors.h"
  25. #include "net/base/network_isolation_key.h"
  26. #include "net/base/port_util.h"
  27. #include "net/base/privacy_mode.h"
  28. #include "net/base/proxy_server.h"
  29. #include "net/base/schemeful_site.h"
  30. #include "net/base/test_completion_callback.h"
  31. #include "net/base/test_proxy_delegate.h"
  32. #include "net/cert/ct_policy_enforcer.h"
  33. #include "net/cert/mock_cert_verifier.h"
  34. #include "net/cert/multi_log_ct_verifier.h"
  35. #include "net/dns/mock_host_resolver.h"
  36. #include "net/dns/public/secure_dns_policy.h"
  37. #include "net/http/bidirectional_stream_impl.h"
  38. #include "net/http/bidirectional_stream_request_info.h"
  39. #include "net/http/http_auth_handler_factory.h"
  40. #include "net/http/http_network_session.h"
  41. #include "net/http/http_network_session_peer.h"
  42. #include "net/http/http_network_transaction.h"
  43. #include "net/http/http_proxy_connect_job.h"
  44. #include "net/http/http_request_info.h"
  45. #include "net/http/http_server_properties.h"
  46. #include "net/http/http_stream.h"
  47. #include "net/http/transport_security_state.h"
  48. #include "net/log/net_log_with_source.h"
  49. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  50. #include "net/proxy_resolution/proxy_info.h"
  51. #include "net/quic/mock_crypto_client_stream_factory.h"
  52. #include "net/quic/mock_quic_context.h"
  53. #include "net/quic/quic_http_utils.h"
  54. #include "net/quic/quic_stream_factory_peer.h"
  55. #include "net/quic/quic_test_packet_maker.h"
  56. #include "net/quic/quic_test_packet_printer.h"
  57. #include "net/socket/client_socket_handle.h"
  58. #include "net/socket/client_socket_pool.h"
  59. #include "net/socket/connect_job.h"
  60. #include "net/socket/mock_client_socket_pool_manager.h"
  61. #include "net/socket/next_proto.h"
  62. #include "net/socket/socket_tag.h"
  63. #include "net/socket/socket_test_util.h"
  64. #include "net/socket/socks_connect_job.h"
  65. #include "net/socket/ssl_connect_job.h"
  66. #include "net/socket/transport_connect_job.h"
  67. #include "net/spdy/spdy_session.h"
  68. #include "net/spdy/spdy_session_pool.h"
  69. #include "net/spdy/spdy_test_util_common.h"
  70. #include "net/ssl/ssl_config_service.h"
  71. #include "net/ssl/ssl_config_service_defaults.h"
  72. #include "net/test/cert_test_util.h"
  73. #include "net/test/gtest_util.h"
  74. #include "net/test/test_data_directory.h"
  75. #include "net/test/test_with_task_environment.h"
  76. #include "net/third_party/quiche/src/quiche/quic/core/quic_server_id.h"
  77. #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
  78. #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
  79. #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
  80. #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
  81. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  82. // This file can be included from net/http even though
  83. // it is in net/websockets because it doesn't
  84. // introduce any link dependency to net/websockets.
  85. #include "net/websockets/websocket_handshake_stream_base.h"
  86. #include "testing/gmock/include/gmock/gmock.h"
  87. #include "testing/gtest/include/gtest/gtest.h"
  88. #include "third_party/abseil-cpp/absl/types/optional.h"
  89. #include "url/gurl.h"
  90. #include "url/scheme_host_port.h"
  91. #include "url/url_constants.h"
  92. using ::testing::Contains;
  93. using ::testing::ElementsAre;
  94. using ::testing::IsEmpty;
  95. using ::testing::Key;
  96. using ::testing::SizeIs;
  97. using net::test::IsError;
  98. using net::test::IsOk;
  99. namespace base {
  100. class Value;
  101. } // namespace base
  102. namespace net {
  103. class BidirectionalStreamImpl;
  104. class WebSocketEndpointLockManager;
  105. namespace {
  106. class MockWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
  107. public:
  108. enum StreamType {
  109. kStreamTypeBasic,
  110. kStreamTypeSpdy,
  111. };
  112. explicit MockWebSocketHandshakeStream(StreamType type) : type_(type) {}
  113. ~MockWebSocketHandshakeStream() override = default;
  114. StreamType type() const { return type_; }
  115. // HttpStream methods
  116. void RegisterRequest(const HttpRequestInfo* request_info) override {}
  117. int InitializeStream(bool can_send_early,
  118. RequestPriority priority,
  119. const NetLogWithSource& net_log,
  120. CompletionOnceCallback callback) override {
  121. return ERR_IO_PENDING;
  122. }
  123. int SendRequest(const HttpRequestHeaders& request_headers,
  124. HttpResponseInfo* response,
  125. CompletionOnceCallback callback) override {
  126. return ERR_IO_PENDING;
  127. }
  128. int ReadResponseHeaders(CompletionOnceCallback callback) override {
  129. return ERR_IO_PENDING;
  130. }
  131. int ReadResponseBody(IOBuffer* buf,
  132. int buf_len,
  133. CompletionOnceCallback callback) override {
  134. return ERR_IO_PENDING;
  135. }
  136. void Close(bool not_reusable) override {}
  137. bool IsResponseBodyComplete() const override { return false; }
  138. bool IsConnectionReused() const override { return false; }
  139. void SetConnectionReused() override {}
  140. bool CanReuseConnection() const override { return false; }
  141. int64_t GetTotalReceivedBytes() const override { return 0; }
  142. int64_t GetTotalSentBytes() const override { return 0; }
  143. bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
  144. return false;
  145. }
  146. bool GetAlternativeService(
  147. AlternativeService* alternative_service) const override {
  148. return false;
  149. }
  150. void GetSSLInfo(SSLInfo* ssl_info) override {}
  151. void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
  152. int GetRemoteEndpoint(IPEndPoint* endpoint) override {
  153. return ERR_UNEXPECTED;
  154. }
  155. void Drain(HttpNetworkSession* session) override {}
  156. void PopulateNetErrorDetails(NetErrorDetails* details) override { return; }
  157. void SetPriority(RequestPriority priority) override {}
  158. std::unique_ptr<HttpStream> RenewStreamForAuth() override { return nullptr; }
  159. const std::set<std::string>& GetDnsAliases() const override {
  160. static const base::NoDestructor<std::set<std::string>> nullset_result;
  161. return *nullset_result;
  162. }
  163. base::StringPiece GetAcceptChViaAlps() const override { return {}; }
  164. std::unique_ptr<WebSocketStream> Upgrade() override { return nullptr; }
  165. base::WeakPtr<WebSocketHandshakeStreamBase> GetWeakPtr() override {
  166. return weak_ptr_factory_.GetWeakPtr();
  167. }
  168. private:
  169. const StreamType type_;
  170. base::WeakPtrFactory<MockWebSocketHandshakeStream> weak_ptr_factory_{this};
  171. };
  172. // HttpStreamFactory subclass that can wait until a preconnect is complete.
  173. class MockHttpStreamFactoryForPreconnect : public HttpStreamFactory {
  174. public:
  175. explicit MockHttpStreamFactoryForPreconnect(HttpNetworkSession* session)
  176. : HttpStreamFactory(session) {}
  177. ~MockHttpStreamFactoryForPreconnect() override = default;
  178. void WaitForPreconnects() {
  179. while (!preconnect_done_) {
  180. waiting_for_preconnect_ = true;
  181. loop_.Run();
  182. waiting_for_preconnect_ = false;
  183. }
  184. }
  185. private:
  186. // HttpStreamFactory methods.
  187. void OnPreconnectsCompleteInternal() override {
  188. preconnect_done_ = true;
  189. if (waiting_for_preconnect_)
  190. loop_.QuitWhenIdle();
  191. }
  192. bool preconnect_done_ = false;
  193. bool waiting_for_preconnect_ = false;
  194. base::RunLoop loop_;
  195. };
  196. class StreamRequestWaiter : public HttpStreamRequest::Delegate {
  197. public:
  198. StreamRequestWaiter() = default;
  199. StreamRequestWaiter(const StreamRequestWaiter&) = delete;
  200. StreamRequestWaiter& operator=(const StreamRequestWaiter&) = delete;
  201. // HttpStreamRequest::Delegate
  202. void OnStreamReady(const SSLConfig& used_ssl_config,
  203. const ProxyInfo& used_proxy_info,
  204. std::unique_ptr<HttpStream> stream) override {
  205. stream_done_ = true;
  206. if (loop_)
  207. loop_->Quit();
  208. stream_ = std::move(stream);
  209. used_ssl_config_ = used_ssl_config;
  210. used_proxy_info_ = used_proxy_info;
  211. }
  212. void OnWebSocketHandshakeStreamReady(
  213. const SSLConfig& used_ssl_config,
  214. const ProxyInfo& used_proxy_info,
  215. std::unique_ptr<WebSocketHandshakeStreamBase> stream) override {
  216. stream_done_ = true;
  217. if (loop_)
  218. loop_->Quit();
  219. websocket_stream_ = std::move(stream);
  220. used_ssl_config_ = used_ssl_config;
  221. used_proxy_info_ = used_proxy_info;
  222. }
  223. void OnBidirectionalStreamImplReady(
  224. const SSLConfig& used_ssl_config,
  225. const ProxyInfo& used_proxy_info,
  226. std::unique_ptr<BidirectionalStreamImpl> stream) override {
  227. stream_done_ = true;
  228. if (loop_)
  229. loop_->Quit();
  230. bidirectional_stream_impl_ = std::move(stream);
  231. used_ssl_config_ = used_ssl_config;
  232. used_proxy_info_ = used_proxy_info;
  233. }
  234. void OnStreamFailed(int status,
  235. const NetErrorDetails& net_error_details,
  236. const SSLConfig& used_ssl_config,
  237. const ProxyInfo& used_proxy_info,
  238. ResolveErrorInfo resolve_error_info) override {
  239. stream_done_ = true;
  240. if (loop_)
  241. loop_->Quit();
  242. used_ssl_config_ = used_ssl_config;
  243. error_status_ = status;
  244. }
  245. void OnCertificateError(int status,
  246. const SSLConfig& used_ssl_config,
  247. const SSLInfo& ssl_info) override {}
  248. void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
  249. const SSLConfig& used_ssl_config,
  250. const ProxyInfo& used_proxy_info,
  251. HttpAuthController* auth_controller) override {}
  252. void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
  253. SSLCertRequestInfo* cert_info) override {}
  254. void OnQuicBroken() override {}
  255. void WaitForStream() {
  256. stream_done_ = false;
  257. loop_ = std::make_unique<base::RunLoop>();
  258. while (!stream_done_)
  259. loop_->Run();
  260. loop_.reset();
  261. }
  262. const SSLConfig& used_ssl_config() const { return used_ssl_config_; }
  263. const ProxyInfo& used_proxy_info() const { return used_proxy_info_; }
  264. HttpStream* stream() { return stream_.get(); }
  265. MockWebSocketHandshakeStream* websocket_stream() {
  266. return static_cast<MockWebSocketHandshakeStream*>(websocket_stream_.get());
  267. }
  268. BidirectionalStreamImpl* bidirectional_stream_impl() {
  269. return bidirectional_stream_impl_.get();
  270. }
  271. bool stream_done() const { return stream_done_; }
  272. int error_status() const { return error_status_; }
  273. protected:
  274. bool stream_done_ = false;
  275. std::unique_ptr<base::RunLoop> loop_;
  276. std::unique_ptr<HttpStream> stream_;
  277. std::unique_ptr<WebSocketHandshakeStreamBase> websocket_stream_;
  278. std::unique_ptr<BidirectionalStreamImpl> bidirectional_stream_impl_;
  279. SSLConfig used_ssl_config_;
  280. ProxyInfo used_proxy_info_;
  281. int error_status_ = OK;
  282. };
  283. class WebSocketBasicHandshakeStream : public MockWebSocketHandshakeStream {
  284. public:
  285. explicit WebSocketBasicHandshakeStream(
  286. std::unique_ptr<ClientSocketHandle> connection)
  287. : MockWebSocketHandshakeStream(kStreamTypeBasic),
  288. connection_(std::move(connection)) {}
  289. ~WebSocketBasicHandshakeStream() override {
  290. connection_->socket()->Disconnect();
  291. }
  292. ClientSocketHandle* connection() { return connection_.get(); }
  293. private:
  294. std::unique_ptr<ClientSocketHandle> connection_;
  295. };
  296. class WebSocketStreamCreateHelper
  297. : public WebSocketHandshakeStreamBase::CreateHelper {
  298. public:
  299. ~WebSocketStreamCreateHelper() override = default;
  300. std::unique_ptr<WebSocketHandshakeStreamBase> CreateBasicStream(
  301. std::unique_ptr<ClientSocketHandle> connection,
  302. bool using_proxy,
  303. WebSocketEndpointLockManager* websocket_endpoint_lock_manager) override {
  304. return std::make_unique<WebSocketBasicHandshakeStream>(
  305. std::move(connection));
  306. }
  307. std::unique_ptr<WebSocketHandshakeStreamBase> CreateHttp2Stream(
  308. base::WeakPtr<SpdySession> session,
  309. std::set<std::string> dns_aliases) override {
  310. NOTREACHED();
  311. return nullptr;
  312. }
  313. };
  314. struct TestCase {
  315. int num_streams;
  316. bool ssl;
  317. };
  318. TestCase kTests[] = {
  319. {1, false},
  320. {2, false},
  321. {1, true},
  322. {2, true},
  323. };
  324. void PreconnectHelperForURL(int num_streams,
  325. const GURL& url,
  326. NetworkIsolationKey network_isolation_key,
  327. SecureDnsPolicy secure_dns_policy,
  328. HttpNetworkSession* session) {
  329. HttpNetworkSessionPeer peer(session);
  330. auto mock_factory =
  331. std::make_unique<MockHttpStreamFactoryForPreconnect>(session);
  332. auto* mock_factory_ptr = mock_factory.get();
  333. peer.SetHttpStreamFactory(std::move(mock_factory));
  334. HttpRequestInfo request;
  335. request.method = "GET";
  336. request.url = url;
  337. request.load_flags = 0;
  338. request.network_isolation_key = network_isolation_key;
  339. request.secure_dns_policy = secure_dns_policy;
  340. request.traffic_annotation =
  341. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  342. session->http_stream_factory()->PreconnectStreams(num_streams, request);
  343. mock_factory_ptr->WaitForPreconnects();
  344. }
  345. void PreconnectHelper(const TestCase& test, HttpNetworkSession* session) {
  346. GURL url =
  347. test.ssl ? GURL("https://www.google.com") : GURL("http://www.google.com");
  348. PreconnectHelperForURL(test.num_streams, url, NetworkIsolationKey(),
  349. SecureDnsPolicy::kAllow, session);
  350. }
  351. ClientSocketPool::GroupId GetGroupId(const TestCase& test) {
  352. if (test.ssl) {
  353. return ClientSocketPool::GroupId(
  354. url::SchemeHostPort(url::kHttpsScheme, "www.google.com", 443),
  355. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  356. SecureDnsPolicy::kAllow);
  357. }
  358. return ClientSocketPool::GroupId(
  359. url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
  360. PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  361. SecureDnsPolicy::kAllow);
  362. }
  363. class CapturePreconnectsTransportSocketPool : public TransportClientSocketPool {
  364. public:
  365. explicit CapturePreconnectsTransportSocketPool(
  366. const CommonConnectJobParams* common_connect_job_params)
  367. : TransportClientSocketPool(0,
  368. 0,
  369. base::TimeDelta(),
  370. ProxyServer::Direct(),
  371. false /* is_for_websockets */,
  372. common_connect_job_params) {}
  373. int last_num_streams() const { return last_num_streams_; }
  374. const ClientSocketPool::GroupId& last_group_id() const {
  375. return last_group_id_;
  376. }
  377. // Resets |last_num_streams_| and |last_group_id_| default values.
  378. void reset() {
  379. last_num_streams_ = -1;
  380. // Group ID that shouldn't match much.
  381. last_group_id_ = ClientSocketPool::GroupId(
  382. url::SchemeHostPort(url::kHttpsScheme,
  383. "unexpected.to.conflict.with.anything.test", 9999),
  384. PrivacyMode::PRIVACY_MODE_ENABLED, NetworkIsolationKey(),
  385. SecureDnsPolicy::kAllow);
  386. }
  387. int RequestSocket(
  388. const ClientSocketPool::GroupId& group_id,
  389. scoped_refptr<ClientSocketPool::SocketParams> socket_params,
  390. const absl::optional<NetworkTrafficAnnotationTag>& proxy_annotation_tag,
  391. RequestPriority priority,
  392. const SocketTag& socket_tag,
  393. ClientSocketPool::RespectLimits respect_limits,
  394. ClientSocketHandle* handle,
  395. CompletionOnceCallback callback,
  396. const ClientSocketPool::ProxyAuthCallback& proxy_auth_callback,
  397. const NetLogWithSource& net_log) override {
  398. ADD_FAILURE();
  399. return ERR_UNEXPECTED;
  400. }
  401. int RequestSockets(
  402. const ClientSocketPool::GroupId& group_id,
  403. scoped_refptr<ClientSocketPool::SocketParams> socket_params,
  404. const absl::optional<NetworkTrafficAnnotationTag>& proxy_annotation_tag,
  405. int num_sockets,
  406. CompletionOnceCallback callback,
  407. const NetLogWithSource& net_log) override {
  408. last_num_streams_ = num_sockets;
  409. last_group_id_ = group_id;
  410. return OK;
  411. }
  412. void CancelRequest(const ClientSocketPool::GroupId& group_id,
  413. ClientSocketHandle* handle,
  414. bool cancel_connect_job) override {
  415. ADD_FAILURE();
  416. }
  417. void ReleaseSocket(const ClientSocketPool::GroupId& group_id,
  418. std::unique_ptr<StreamSocket> socket,
  419. int64_t generation) override {
  420. ADD_FAILURE();
  421. }
  422. void CloseIdleSockets(const char* net_log_reason_utf8) override {
  423. ADD_FAILURE();
  424. }
  425. int IdleSocketCount() const override {
  426. ADD_FAILURE();
  427. return 0;
  428. }
  429. size_t IdleSocketCountInGroup(
  430. const ClientSocketPool::GroupId& group_id) const override {
  431. ADD_FAILURE();
  432. return 0;
  433. }
  434. LoadState GetLoadState(const ClientSocketPool::GroupId& group_id,
  435. const ClientSocketHandle* handle) const override {
  436. ADD_FAILURE();
  437. return LOAD_STATE_IDLE;
  438. }
  439. private:
  440. int last_num_streams_ = -1;
  441. ClientSocketPool::GroupId last_group_id_;
  442. };
  443. using HttpStreamFactoryTest = TestWithTaskEnvironment;
  444. TEST_F(HttpStreamFactoryTest, PreconnectDirect) {
  445. for (const auto& test : kTests) {
  446. SpdySessionDependencies session_deps(
  447. ConfiguredProxyResolutionService::CreateDirect());
  448. std::unique_ptr<HttpNetworkSession> session(
  449. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  450. HttpNetworkSessionPeer peer(session.get());
  451. CommonConnectJobParams common_connect_job_params =
  452. session->CreateCommonConnectJobParams();
  453. std::unique_ptr<CapturePreconnectsTransportSocketPool>
  454. owned_transport_conn_pool =
  455. std::make_unique<CapturePreconnectsTransportSocketPool>(
  456. &common_connect_job_params);
  457. CapturePreconnectsTransportSocketPool* transport_conn_pool =
  458. owned_transport_conn_pool.get();
  459. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  460. mock_pool_manager->SetSocketPool(ProxyServer::Direct(),
  461. std::move(owned_transport_conn_pool));
  462. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  463. PreconnectHelper(test, session.get());
  464. EXPECT_EQ(test.num_streams, transport_conn_pool->last_num_streams());
  465. EXPECT_EQ(GetGroupId(test), transport_conn_pool->last_group_id());
  466. }
  467. }
  468. TEST_F(HttpStreamFactoryTest, PreconnectHttpProxy) {
  469. for (const auto& test : kTests) {
  470. SpdySessionDependencies session_deps(
  471. ConfiguredProxyResolutionService::CreateFixedForTest(
  472. "http_proxy", TRAFFIC_ANNOTATION_FOR_TESTS));
  473. std::unique_ptr<HttpNetworkSession> session(
  474. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  475. HttpNetworkSessionPeer peer(session.get());
  476. ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
  477. HostPortPair("http_proxy", 80));
  478. CommonConnectJobParams common_connect_job_params =
  479. session->CreateCommonConnectJobParams();
  480. auto http_proxy_pool =
  481. std::make_unique<CapturePreconnectsTransportSocketPool>(
  482. &common_connect_job_params);
  483. auto* http_proxy_pool_ptr = http_proxy_pool.get();
  484. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  485. mock_pool_manager->SetSocketPool(proxy_server, std::move(http_proxy_pool));
  486. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  487. PreconnectHelper(test, session.get());
  488. EXPECT_EQ(test.num_streams, http_proxy_pool_ptr->last_num_streams());
  489. EXPECT_EQ(GetGroupId(test), http_proxy_pool_ptr->last_group_id());
  490. }
  491. }
  492. TEST_F(HttpStreamFactoryTest, PreconnectSocksProxy) {
  493. for (const auto& test : kTests) {
  494. SpdySessionDependencies session_deps(
  495. ConfiguredProxyResolutionService::CreateFixedForTest(
  496. "socks4://socks_proxy:1080", TRAFFIC_ANNOTATION_FOR_TESTS));
  497. std::unique_ptr<HttpNetworkSession> session(
  498. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  499. HttpNetworkSessionPeer peer(session.get());
  500. ProxyServer proxy_server(ProxyServer::SCHEME_SOCKS4,
  501. HostPortPair("socks_proxy", 1080));
  502. CommonConnectJobParams common_connect_job_params =
  503. session->CreateCommonConnectJobParams();
  504. auto socks_proxy_pool =
  505. std::make_unique<CapturePreconnectsTransportSocketPool>(
  506. &common_connect_job_params);
  507. auto* socks_proxy_pool_ptr = socks_proxy_pool.get();
  508. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  509. mock_pool_manager->SetSocketPool(proxy_server, std::move(socks_proxy_pool));
  510. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  511. PreconnectHelper(test, session.get());
  512. EXPECT_EQ(test.num_streams, socks_proxy_pool_ptr->last_num_streams());
  513. EXPECT_EQ(GetGroupId(test), socks_proxy_pool_ptr->last_group_id());
  514. }
  515. }
  516. TEST_F(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
  517. for (const auto& test : kTests) {
  518. SpdySessionDependencies session_deps(
  519. ConfiguredProxyResolutionService::CreateDirect());
  520. std::unique_ptr<HttpNetworkSession> session(
  521. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  522. HttpNetworkSessionPeer peer(session.get());
  523. // Put a SpdySession in the pool.
  524. HostPortPair host_port_pair("www.google.com", 443);
  525. SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
  526. PRIVACY_MODE_DISABLED,
  527. SpdySessionKey::IsProxySession::kFalse, SocketTag(),
  528. NetworkIsolationKey(), SecureDnsPolicy::kAllow);
  529. std::ignore = CreateFakeSpdySession(session->spdy_session_pool(), key);
  530. CommonConnectJobParams common_connect_job_params =
  531. session->CreateCommonConnectJobParams();
  532. std::unique_ptr<CapturePreconnectsTransportSocketPool>
  533. owned_transport_conn_pool =
  534. std::make_unique<CapturePreconnectsTransportSocketPool>(
  535. &common_connect_job_params);
  536. CapturePreconnectsTransportSocketPool* transport_conn_pool =
  537. owned_transport_conn_pool.get();
  538. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  539. mock_pool_manager->SetSocketPool(ProxyServer::Direct(),
  540. std::move(owned_transport_conn_pool));
  541. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  542. PreconnectHelper(test, session.get());
  543. // We shouldn't be preconnecting if we have an existing session, which is
  544. // the case for https://www.google.com.
  545. if (test.ssl)
  546. EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
  547. else
  548. EXPECT_EQ(test.num_streams, transport_conn_pool->last_num_streams());
  549. }
  550. }
  551. // Verify that preconnects to unsafe ports are cancelled before they reach
  552. // the SocketPool.
  553. TEST_F(HttpStreamFactoryTest, PreconnectUnsafePort) {
  554. ASSERT_FALSE(IsPortAllowedForScheme(7, "http"));
  555. SpdySessionDependencies session_deps(
  556. ConfiguredProxyResolutionService::CreateDirect());
  557. std::unique_ptr<HttpNetworkSession> session(
  558. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  559. HttpNetworkSessionPeer peer(session.get());
  560. CommonConnectJobParams common_connect_job_params =
  561. session->CreateCommonConnectJobParams();
  562. std::unique_ptr<CapturePreconnectsTransportSocketPool>
  563. owned_transport_conn_pool =
  564. std::make_unique<CapturePreconnectsTransportSocketPool>(
  565. &common_connect_job_params);
  566. CapturePreconnectsTransportSocketPool* transport_conn_pool =
  567. owned_transport_conn_pool.get();
  568. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  569. mock_pool_manager->SetSocketPool(ProxyServer::Direct(),
  570. std::move(owned_transport_conn_pool));
  571. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  572. PreconnectHelperForURL(1, GURL("http://www.google.com:7"),
  573. NetworkIsolationKey(), SecureDnsPolicy::kAllow,
  574. session.get());
  575. EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
  576. }
  577. // Verify that preconnects use the specified NetworkIsolationKey.
  578. TEST_F(HttpStreamFactoryTest, PreconnectNetworkIsolationKey) {
  579. base::test::ScopedFeatureList feature_list;
  580. feature_list.InitAndEnableFeature(
  581. features::kPartitionConnectionsByNetworkIsolationKey);
  582. SpdySessionDependencies session_deps(
  583. ConfiguredProxyResolutionService::CreateDirect());
  584. std::unique_ptr<HttpNetworkSession> session(
  585. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  586. HttpNetworkSessionPeer peer(session.get());
  587. CommonConnectJobParams common_connect_job_params =
  588. session->CreateCommonConnectJobParams();
  589. std::unique_ptr<CapturePreconnectsTransportSocketPool>
  590. owned_transport_conn_pool =
  591. std::make_unique<CapturePreconnectsTransportSocketPool>(
  592. &common_connect_job_params);
  593. CapturePreconnectsTransportSocketPool* transport_conn_pool =
  594. owned_transport_conn_pool.get();
  595. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  596. mock_pool_manager->SetSocketPool(ProxyServer::Direct(),
  597. std::move(owned_transport_conn_pool));
  598. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  599. const GURL kURL("http://foo.test/");
  600. SchemefulSite kSiteFoo(GURL("http://foo.test"));
  601. SchemefulSite kSiteBar(GURL("http://bar.test"));
  602. const NetworkIsolationKey kKey1(kSiteFoo, kSiteFoo);
  603. const NetworkIsolationKey kKey2(kSiteBar, kSiteBar);
  604. PreconnectHelperForURL(1, kURL, kKey1, SecureDnsPolicy::kAllow,
  605. session.get());
  606. EXPECT_EQ(1, transport_conn_pool->last_num_streams());
  607. EXPECT_EQ(kKey1,
  608. transport_conn_pool->last_group_id().network_isolation_key());
  609. PreconnectHelperForURL(2, kURL, kKey2, SecureDnsPolicy::kAllow,
  610. session.get());
  611. EXPECT_EQ(2, transport_conn_pool->last_num_streams());
  612. EXPECT_EQ(kKey2,
  613. transport_conn_pool->last_group_id().network_isolation_key());
  614. }
  615. // Verify that preconnects use the specified Secure DNS Tag.
  616. TEST_F(HttpStreamFactoryTest, PreconnectDisableSecureDns) {
  617. SpdySessionDependencies session_deps(
  618. ConfiguredProxyResolutionService::CreateDirect());
  619. std::unique_ptr<HttpNetworkSession> session(
  620. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  621. HttpNetworkSessionPeer peer(session.get());
  622. CommonConnectJobParams common_connect_job_params =
  623. session->CreateCommonConnectJobParams();
  624. std::unique_ptr<CapturePreconnectsTransportSocketPool>
  625. owned_transport_conn_pool =
  626. std::make_unique<CapturePreconnectsTransportSocketPool>(
  627. &common_connect_job_params);
  628. CapturePreconnectsTransportSocketPool* transport_conn_pool =
  629. owned_transport_conn_pool.get();
  630. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  631. mock_pool_manager->SetSocketPool(ProxyServer::Direct(),
  632. std::move(owned_transport_conn_pool));
  633. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  634. const GURL kURL("http://foo.test/");
  635. SchemefulSite kSiteFoo(GURL("http://foo.test"));
  636. SchemefulSite kSiteBar(GURL("http://bar.test"));
  637. PreconnectHelperForURL(1, kURL, NetworkIsolationKey(),
  638. SecureDnsPolicy::kAllow, session.get());
  639. EXPECT_EQ(1, transport_conn_pool->last_num_streams());
  640. EXPECT_EQ(SecureDnsPolicy::kAllow,
  641. transport_conn_pool->last_group_id().secure_dns_policy());
  642. PreconnectHelperForURL(2, kURL, NetworkIsolationKey(),
  643. SecureDnsPolicy::kDisable, session.get());
  644. EXPECT_EQ(2, transport_conn_pool->last_num_streams());
  645. EXPECT_EQ(SecureDnsPolicy::kDisable,
  646. transport_conn_pool->last_group_id().secure_dns_policy());
  647. }
  648. TEST_F(HttpStreamFactoryTest, JobNotifiesProxy) {
  649. const char* kProxyString = "PROXY bad:99; PROXY maybe:80; DIRECT";
  650. SpdySessionDependencies session_deps(
  651. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  652. kProxyString, TRAFFIC_ANNOTATION_FOR_TESTS));
  653. // First connection attempt fails
  654. StaticSocketDataProvider socket_data1;
  655. socket_data1.set_connect_data(MockConnect(ASYNC, ERR_ADDRESS_UNREACHABLE));
  656. session_deps.socket_factory->AddSocketDataProvider(&socket_data1);
  657. // Second connection attempt succeeds
  658. StaticSocketDataProvider socket_data2;
  659. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  660. session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
  661. std::unique_ptr<HttpNetworkSession> session(
  662. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  663. // Now request a stream. It should succeed using the second proxy in the
  664. // list.
  665. HttpRequestInfo request_info;
  666. request_info.method = "GET";
  667. request_info.url = GURL("http://www.google.com");
  668. request_info.traffic_annotation =
  669. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  670. SSLConfig ssl_config;
  671. StreamRequestWaiter waiter;
  672. std::unique_ptr<HttpStreamRequest> request(
  673. session->http_stream_factory()->RequestStream(
  674. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  675. /* enable_ip_based_pooling = */ true,
  676. /* enable_alternative_services = */ true, NetLogWithSource()));
  677. waiter.WaitForStream();
  678. // The proxy that failed should now be known to the proxy_resolution_service
  679. // as bad.
  680. const ProxyRetryInfoMap& retry_info =
  681. session->proxy_resolution_service()->proxy_retry_info();
  682. EXPECT_EQ(1u, retry_info.size());
  683. auto iter = retry_info.find("bad:99");
  684. EXPECT_TRUE(iter != retry_info.end());
  685. }
  686. // This test requests a stream for an https:// URL using an HTTP proxy.
  687. // The proxy will fail to establish a tunnel via connect, and the resolved
  688. // proxy list includes a fallback to DIRECT.
  689. //
  690. // The expected behavior is that proxy fallback does NOT occur, even though the
  691. // request might work using the fallback. This is a regression test for
  692. // https://crbug.com/680837.
  693. TEST_F(HttpStreamFactoryTest, NoProxyFallbackOnTunnelFail) {
  694. const char* kProxyString = "PROXY bad:99; DIRECT";
  695. SpdySessionDependencies session_deps(
  696. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  697. kProxyString, TRAFFIC_ANNOTATION_FOR_TESTS));
  698. // A 404 in response to a CONNECT will trigger
  699. // ERR_TUNNEL_CONNECTION_FAILED.
  700. MockRead data_reads[] = {
  701. MockRead("HTTP/1.1 404 Not Found\r\n\r\n"), MockRead(SYNCHRONOUS, OK),
  702. };
  703. // Simulate a failure during CONNECT to bad:99.
  704. StaticSocketDataProvider socket_data1(data_reads, base::span<MockWrite>());
  705. socket_data1.set_connect_data(MockConnect(SYNCHRONOUS, OK));
  706. session_deps.socket_factory->AddSocketDataProvider(&socket_data1);
  707. std::unique_ptr<HttpNetworkSession> session(
  708. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  709. // Request a stream for an https:// URL. The exact URL doesn't matter for
  710. // this test, since it mocks a failure immediately when establishing a
  711. // tunnel through the proxy.
  712. HttpRequestInfo request_info;
  713. request_info.method = "GET";
  714. request_info.url = GURL("https://www.google.com");
  715. request_info.traffic_annotation =
  716. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  717. SSLConfig ssl_config;
  718. StreamRequestWaiter waiter;
  719. std::unique_ptr<HttpStreamRequest> request(
  720. session->http_stream_factory()->RequestStream(
  721. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  722. /* enable_ip_based_pooling = */ true,
  723. /* enable_alternative_services = */ true, NetLogWithSource()));
  724. waiter.WaitForStream();
  725. // The stream should have failed, since the proxy server failed to
  726. // establish a tunnel.
  727. ASSERT_THAT(waiter.error_status(), IsError(ERR_TUNNEL_CONNECTION_FAILED));
  728. // The proxy should NOT have been marked as bad.
  729. const ProxyRetryInfoMap& retry_info =
  730. session->proxy_resolution_service()->proxy_retry_info();
  731. EXPECT_EQ(0u, retry_info.size());
  732. }
  733. // List of errors that are used in the tests related to QUIC proxy.
  734. const int quic_proxy_test_mock_errors[] = {
  735. ERR_PROXY_CONNECTION_FAILED,
  736. ERR_NAME_NOT_RESOLVED,
  737. ERR_ADDRESS_UNREACHABLE,
  738. ERR_CONNECTION_CLOSED,
  739. ERR_CONNECTION_TIMED_OUT,
  740. ERR_CONNECTION_RESET,
  741. ERR_CONNECTION_REFUSED,
  742. ERR_CONNECTION_ABORTED,
  743. ERR_TIMED_OUT,
  744. ERR_SOCKS_CONNECTION_FAILED,
  745. ERR_PROXY_CERTIFICATE_INVALID,
  746. ERR_QUIC_PROTOCOL_ERROR,
  747. ERR_QUIC_HANDSHAKE_FAILED,
  748. ERR_SSL_PROTOCOL_ERROR,
  749. ERR_MSG_TOO_BIG,
  750. };
  751. // Tests that a bad QUIC proxy is added to the list of bad proxies.
  752. TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) {
  753. for (int quic_proxy_test_mock_error : quic_proxy_test_mock_errors) {
  754. std::unique_ptr<ProxyResolutionService> proxy_resolution_service =
  755. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  756. "QUIC bad:99; DIRECT", TRAFFIC_ANNOTATION_FOR_TESTS);
  757. HttpNetworkSessionParams session_params;
  758. session_params.enable_quic = true;
  759. HttpNetworkSessionContext session_context;
  760. SSLConfigServiceDefaults ssl_config_service;
  761. HttpServerProperties http_server_properties;
  762. MockClientSocketFactory socket_factory;
  763. session_context.client_socket_factory = &socket_factory;
  764. MockHostResolver host_resolver;
  765. session_context.host_resolver = &host_resolver;
  766. MockCertVerifier cert_verifier;
  767. session_context.cert_verifier = &cert_verifier;
  768. TransportSecurityState transport_security_state;
  769. session_context.transport_security_state = &transport_security_state;
  770. DefaultCTPolicyEnforcer ct_policy_enforcer;
  771. QuicContext quic_context;
  772. session_context.ct_policy_enforcer = &ct_policy_enforcer;
  773. session_context.proxy_resolution_service = proxy_resolution_service.get();
  774. session_context.ssl_config_service = &ssl_config_service;
  775. session_context.http_server_properties = &http_server_properties;
  776. session_context.quic_context = &quic_context;
  777. host_resolver.rules()->AddRule("www.google.com", "2.3.4.5");
  778. host_resolver.rules()->AddRule("bad", "1.2.3.4");
  779. auto session =
  780. std::make_unique<HttpNetworkSession>(session_params, session_context);
  781. session->quic_stream_factory()
  782. ->set_is_quic_known_to_work_on_current_network(true);
  783. StaticSocketDataProvider socket_data1;
  784. socket_data1.set_connect_data(
  785. MockConnect(ASYNC, quic_proxy_test_mock_error));
  786. socket_factory.AddSocketDataProvider(&socket_data1);
  787. // Second connection attempt succeeds.
  788. StaticSocketDataProvider socket_data2;
  789. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  790. socket_factory.AddSocketDataProvider(&socket_data2);
  791. // Now request a stream. It should succeed using the second proxy in the
  792. // list.
  793. HttpRequestInfo request_info;
  794. request_info.method = "GET";
  795. request_info.url = GURL("http://www.google.com");
  796. request_info.traffic_annotation =
  797. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  798. SSLConfig ssl_config;
  799. StreamRequestWaiter waiter;
  800. std::unique_ptr<HttpStreamRequest> request(
  801. session->http_stream_factory()->RequestStream(
  802. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  803. /* enable_ip_based_pooling = */ true,
  804. /* enable_alternative_services = */ true, NetLogWithSource()));
  805. waiter.WaitForStream();
  806. // The proxy that failed should now be known to the
  807. // proxy_resolution_service as bad.
  808. const ProxyRetryInfoMap& retry_info =
  809. session->proxy_resolution_service()->proxy_retry_info();
  810. EXPECT_EQ(1u, retry_info.size()) << quic_proxy_test_mock_error;
  811. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  812. auto iter = retry_info.find("quic://bad:99");
  813. EXPECT_TRUE(iter != retry_info.end()) << quic_proxy_test_mock_error;
  814. }
  815. }
  816. // BidirectionalStreamImpl::Delegate to wait until response headers are
  817. // received.
  818. class TestBidirectionalDelegate : public BidirectionalStreamImpl::Delegate {
  819. public:
  820. void WaitUntilDone() { loop_.Run(); }
  821. const spdy::Http2HeaderBlock& response_headers() const {
  822. return response_headers_;
  823. }
  824. private:
  825. void OnStreamReady(bool request_headers_sent) override {}
  826. void OnHeadersReceived(
  827. const spdy::Http2HeaderBlock& response_headers) override {
  828. response_headers_ = response_headers.Clone();
  829. loop_.Quit();
  830. }
  831. void OnDataRead(int bytes_read) override { NOTREACHED(); }
  832. void OnDataSent() override { NOTREACHED(); }
  833. void OnTrailersReceived(const spdy::Http2HeaderBlock& trailers) override {
  834. NOTREACHED();
  835. }
  836. void OnFailed(int error) override { NOTREACHED(); }
  837. base::RunLoop loop_;
  838. spdy::Http2HeaderBlock response_headers_;
  839. };
  840. // Helper class to encapsulate MockReads and MockWrites for QUIC.
  841. // Simplify ownership issues and the interaction with the MockSocketFactory.
  842. class MockQuicData {
  843. public:
  844. explicit MockQuicData(quic::ParsedQuicVersion version) : printer_(version) {}
  845. ~MockQuicData() = default;
  846. void AddRead(std::unique_ptr<quic::QuicEncryptedPacket> packet) {
  847. reads_.emplace_back(ASYNC, packet->data(), packet->length(),
  848. packet_number_++);
  849. packets_.push_back(std::move(packet));
  850. }
  851. void AddRead(IoMode mode, int rv) {
  852. reads_.emplace_back(mode, rv, packet_number_++);
  853. }
  854. void AddWrite(std::unique_ptr<quic::QuicEncryptedPacket> packet) {
  855. writes_.emplace_back(SYNCHRONOUS, packet->data(), packet->length(),
  856. packet_number_++);
  857. packets_.push_back(std::move(packet));
  858. }
  859. void AddSocketDataToFactory(MockClientSocketFactory* factory) {
  860. socket_data_ = std::make_unique<SequencedSocketData>(reads_, writes_);
  861. socket_data_->set_printer(&printer_);
  862. factory->AddSocketDataProvider(socket_data_.get());
  863. }
  864. private:
  865. std::vector<std::unique_ptr<quic::QuicEncryptedPacket>> packets_;
  866. std::vector<MockWrite> writes_;
  867. std::vector<MockRead> reads_;
  868. size_t packet_number_ = 0;
  869. QuicPacketPrinter printer_;
  870. std::unique_ptr<SequencedSocketData> socket_data_;
  871. };
  872. } // namespace
  873. TEST_F(HttpStreamFactoryTest, UsePreConnectIfNoZeroRTT) {
  874. for (int num_streams = 1; num_streams < 3; ++num_streams) {
  875. GURL url = GURL("https://www.google.com");
  876. SpdySessionDependencies session_deps(
  877. ConfiguredProxyResolutionService::CreateFixedForTest(
  878. "http_proxy", TRAFFIC_ANNOTATION_FOR_TESTS));
  879. // Setup params to disable preconnect, but QUIC doesn't 0RTT.
  880. HttpNetworkSessionParams session_params =
  881. SpdySessionDependencies::CreateSessionParams(&session_deps);
  882. session_params.enable_quic = true;
  883. // Set up QUIC as alternative_service.
  884. HttpServerProperties http_server_properties;
  885. const AlternativeService alternative_service(kProtoQUIC, url.host().c_str(),
  886. url.IntPort());
  887. base::Time expiration = base::Time::Now() + base::Days(1);
  888. HostPortPair host_port_pair(alternative_service.host_port_pair());
  889. url::SchemeHostPort server("https", host_port_pair.host(),
  890. host_port_pair.port());
  891. http_server_properties.SetQuicAlternativeService(
  892. server, NetworkIsolationKey(), alternative_service, expiration,
  893. DefaultSupportedQuicVersions());
  894. HttpNetworkSessionContext session_context =
  895. SpdySessionDependencies::CreateSessionContext(&session_deps);
  896. session_context.http_server_properties = &http_server_properties;
  897. auto session =
  898. std::make_unique<HttpNetworkSession>(session_params, session_context);
  899. HttpNetworkSessionPeer peer(session.get());
  900. ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
  901. HostPortPair("http_proxy", 80));
  902. CommonConnectJobParams common_connect_job_params =
  903. session->CreateCommonConnectJobParams();
  904. auto http_proxy_pool =
  905. std::make_unique<CapturePreconnectsTransportSocketPool>(
  906. &common_connect_job_params);
  907. auto* http_proxy_pool_ptr = http_proxy_pool.get();
  908. auto mock_pool_manager = std::make_unique<MockClientSocketPoolManager>();
  909. mock_pool_manager->SetSocketPool(proxy_server, std::move(http_proxy_pool));
  910. peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
  911. PreconnectHelperForURL(num_streams, url, NetworkIsolationKey(),
  912. SecureDnsPolicy::kAllow, session.get());
  913. EXPECT_EQ(num_streams, http_proxy_pool_ptr->last_num_streams());
  914. }
  915. }
  916. namespace {
  917. // Return count of distinct groups in given socket pool.
  918. int GetSocketPoolGroupCount(ClientSocketPool* pool) {
  919. int count = 0;
  920. base::Value dict = pool->GetInfoAsValue("", "");
  921. EXPECT_TRUE(dict.is_dict());
  922. const base::Value::Dict* groups = dict.GetDict().FindDict("groups");
  923. if (groups) {
  924. count = groups->size();
  925. }
  926. return count;
  927. }
  928. // Return count of distinct spdy sessions.
  929. int GetSpdySessionCount(HttpNetworkSession* session) {
  930. std::unique_ptr<base::Value> value(
  931. session->spdy_session_pool()->SpdySessionPoolInfoToValue());
  932. if (!value || !value->is_list())
  933. return -1;
  934. return value->GetList().size();
  935. }
  936. // Return count of sockets handed out by a given socket pool.
  937. int GetHandedOutSocketCount(ClientSocketPool* pool) {
  938. base::Value dict = pool->GetInfoAsValue("", "");
  939. EXPECT_TRUE(dict.is_dict());
  940. return dict.GetDict().FindInt("handed_out_socket_count").value_or(-1);
  941. }
  942. // Return count of distinct QUIC sessions.
  943. int GetQuicSessionCount(HttpNetworkSession* session) {
  944. base::Value dict(session->QuicInfoToValue());
  945. base::Value::List* session_list = dict.GetDict().FindList("sessions");
  946. if (!session_list)
  947. return -1;
  948. return session_list->size();
  949. }
  950. TEST_F(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
  951. SpdySessionDependencies session_deps(
  952. ConfiguredProxyResolutionService::CreateDirect());
  953. StaticSocketDataProvider socket_data_1;
  954. socket_data_1.set_connect_data(MockConnect(ASYNC, OK));
  955. session_deps.socket_factory->AddSocketDataProvider(&socket_data_1);
  956. StaticSocketDataProvider socket_data_2;
  957. socket_data_2.set_connect_data(MockConnect(ASYNC, OK));
  958. session_deps.socket_factory->AddSocketDataProvider(&socket_data_2);
  959. StaticSocketDataProvider socket_data_3;
  960. socket_data_3.set_connect_data(MockConnect(ASYNC, OK));
  961. session_deps.socket_factory->AddSocketDataProvider(&socket_data_3);
  962. SSLSocketDataProvider ssl_1(ASYNC, OK);
  963. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_1);
  964. SSLSocketDataProvider ssl_2(ASYNC, OK);
  965. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_2);
  966. SSLSocketDataProvider ssl_3(ASYNC, OK);
  967. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_3);
  968. std::unique_ptr<HttpNetworkSession> session(
  969. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  970. ClientSocketPool* ssl_pool = session->GetSocketPool(
  971. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct());
  972. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 0);
  973. HttpRequestInfo request_info;
  974. request_info.method = "GET";
  975. request_info.url = GURL("https://www.google.com");
  976. request_info.load_flags = 0;
  977. request_info.privacy_mode = PRIVACY_MODE_DISABLED;
  978. request_info.traffic_annotation =
  979. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  980. SSLConfig ssl_config;
  981. StreamRequestWaiter waiter;
  982. std::unique_ptr<HttpStreamRequest> request1(
  983. session->http_stream_factory()->RequestStream(
  984. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  985. /* enable_ip_based_pooling = */ true,
  986. /* enable_alternative_services = */ true, NetLogWithSource()));
  987. waiter.WaitForStream();
  988. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
  989. std::unique_ptr<HttpStreamRequest> request2(
  990. session->http_stream_factory()->RequestStream(
  991. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  992. /* enable_ip_based_pooling = */ true,
  993. /* enable_alternative_services = */ true, NetLogWithSource()));
  994. waiter.WaitForStream();
  995. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
  996. request_info.privacy_mode = PRIVACY_MODE_ENABLED;
  997. std::unique_ptr<HttpStreamRequest> request3(
  998. session->http_stream_factory()->RequestStream(
  999. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1000. /* enable_ip_based_pooling = */ true,
  1001. /* enable_alternative_services = */ true, NetLogWithSource()));
  1002. waiter.WaitForStream();
  1003. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 2);
  1004. }
  1005. TEST_F(HttpStreamFactoryTest, DisableSecureDnsUsesDifferentSocketPoolGroup) {
  1006. SpdySessionDependencies session_deps(
  1007. ConfiguredProxyResolutionService::CreateDirect());
  1008. StaticSocketDataProvider socket_data_1;
  1009. socket_data_1.set_connect_data(MockConnect(ASYNC, OK));
  1010. session_deps.socket_factory->AddSocketDataProvider(&socket_data_1);
  1011. StaticSocketDataProvider socket_data_2;
  1012. socket_data_2.set_connect_data(MockConnect(ASYNC, OK));
  1013. session_deps.socket_factory->AddSocketDataProvider(&socket_data_2);
  1014. StaticSocketDataProvider socket_data_3;
  1015. socket_data_3.set_connect_data(MockConnect(ASYNC, OK));
  1016. session_deps.socket_factory->AddSocketDataProvider(&socket_data_3);
  1017. SSLSocketDataProvider ssl_1(ASYNC, OK);
  1018. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_1);
  1019. SSLSocketDataProvider ssl_2(ASYNC, OK);
  1020. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_2);
  1021. SSLSocketDataProvider ssl_3(ASYNC, OK);
  1022. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_3);
  1023. std::unique_ptr<HttpNetworkSession> session(
  1024. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1025. ClientSocketPool* ssl_pool = session->GetSocketPool(
  1026. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct());
  1027. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 0);
  1028. HttpRequestInfo request_info;
  1029. request_info.method = "GET";
  1030. request_info.url = GURL("https://www.google.com");
  1031. request_info.load_flags = 0;
  1032. request_info.privacy_mode = PRIVACY_MODE_DISABLED;
  1033. request_info.traffic_annotation =
  1034. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1035. request_info.secure_dns_policy = SecureDnsPolicy::kAllow;
  1036. SSLConfig ssl_config;
  1037. StreamRequestWaiter waiter;
  1038. std::unique_ptr<HttpStreamRequest> request1(
  1039. session->http_stream_factory()->RequestStream(
  1040. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1041. /* enable_ip_based_pooling = */ true,
  1042. /* enable_alternative_services = */ true, NetLogWithSource()));
  1043. waiter.WaitForStream();
  1044. EXPECT_EQ(SecureDnsPolicy::kAllow,
  1045. session_deps.host_resolver->last_secure_dns_policy());
  1046. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
  1047. std::unique_ptr<HttpStreamRequest> request2(
  1048. session->http_stream_factory()->RequestStream(
  1049. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1050. /* enable_ip_based_pooling = */ true,
  1051. /* enable_alternative_services = */ true, NetLogWithSource()));
  1052. waiter.WaitForStream();
  1053. EXPECT_EQ(SecureDnsPolicy::kAllow,
  1054. session_deps.host_resolver->last_secure_dns_policy());
  1055. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
  1056. request_info.secure_dns_policy = SecureDnsPolicy::kDisable;
  1057. std::unique_ptr<HttpStreamRequest> request3(
  1058. session->http_stream_factory()->RequestStream(
  1059. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1060. /* enable_ip_based_pooling = */ true,
  1061. /* enable_alternative_services = */ true, NetLogWithSource()));
  1062. waiter.WaitForStream();
  1063. EXPECT_EQ(SecureDnsPolicy::kDisable,
  1064. session_deps.host_resolver->last_secure_dns_policy());
  1065. EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 2);
  1066. }
  1067. TEST_F(HttpStreamFactoryTest, GetLoadState) {
  1068. SpdySessionDependencies session_deps(
  1069. ConfiguredProxyResolutionService::CreateDirect());
  1070. StaticSocketDataProvider socket_data;
  1071. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1072. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1073. std::unique_ptr<HttpNetworkSession> session(
  1074. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1075. HttpRequestInfo request_info;
  1076. request_info.method = "GET";
  1077. request_info.url = GURL("http://www.google.com");
  1078. request_info.traffic_annotation =
  1079. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1080. SSLConfig ssl_config;
  1081. StreamRequestWaiter waiter;
  1082. std::unique_ptr<HttpStreamRequest> request(
  1083. session->http_stream_factory()->RequestStream(
  1084. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1085. /* enable_ip_based_pooling = */ true,
  1086. /* enable_alternative_services = */ true, NetLogWithSource()));
  1087. EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, request->GetLoadState());
  1088. waiter.WaitForStream();
  1089. }
  1090. TEST_F(HttpStreamFactoryTest, RequestHttpStream) {
  1091. SpdySessionDependencies session_deps(
  1092. ConfiguredProxyResolutionService::CreateDirect());
  1093. StaticSocketDataProvider socket_data;
  1094. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1095. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1096. std::unique_ptr<HttpNetworkSession> session(
  1097. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1098. // Now request a stream. It should succeed using the second proxy in the
  1099. // list.
  1100. HttpRequestInfo request_info;
  1101. request_info.method = "GET";
  1102. request_info.url = GURL("http://www.google.com");
  1103. request_info.load_flags = 0;
  1104. request_info.traffic_annotation =
  1105. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1106. SSLConfig ssl_config;
  1107. StreamRequestWaiter waiter;
  1108. std::unique_ptr<HttpStreamRequest> request(
  1109. session->http_stream_factory()->RequestStream(
  1110. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1111. /* enable_ip_based_pooling = */ true,
  1112. /* enable_alternative_services = */ true, NetLogWithSource()));
  1113. waiter.WaitForStream();
  1114. EXPECT_TRUE(waiter.stream_done());
  1115. ASSERT_TRUE(nullptr != waiter.stream());
  1116. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1117. EXPECT_EQ(0, GetSpdySessionCount(session.get()));
  1118. EXPECT_EQ(
  1119. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  1120. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1121. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1122. }
  1123. // Test the race of SetPriority versus stream completion where SetPriority may
  1124. // be called on an HttpStreamFactory::Job after the stream has been created by
  1125. // the job.
  1126. TEST_F(HttpStreamFactoryTest, ReprioritizeAfterStreamReceived) {
  1127. SpdySessionDependencies session_deps(
  1128. ConfiguredProxyResolutionService::CreateDirect());
  1129. session_deps.host_resolver->set_synchronous_mode(true);
  1130. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  1131. StaticSocketDataProvider socket_data(base::make_span(&mock_read, 1),
  1132. base::span<MockWrite>());
  1133. socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
  1134. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1135. SSLSocketDataProvider ssl_socket_data(SYNCHRONOUS, OK);
  1136. ssl_socket_data.next_proto = kProtoHTTP2;
  1137. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1138. std::unique_ptr<HttpNetworkSession> session(
  1139. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1140. // Now request a stream.
  1141. HttpRequestInfo request_info;
  1142. request_info.method = "GET";
  1143. request_info.url = GURL("https://www.google.com");
  1144. request_info.load_flags = 0;
  1145. request_info.traffic_annotation =
  1146. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1147. SSLConfig ssl_config;
  1148. StreamRequestWaiter waiter;
  1149. EXPECT_EQ(0, GetSpdySessionCount(session.get()));
  1150. std::unique_ptr<HttpStreamRequest> request(
  1151. session->http_stream_factory()->RequestStream(
  1152. request_info, LOWEST, ssl_config, ssl_config, &waiter,
  1153. /* enable_ip_based_pooling = */ true,
  1154. /* enable_alternative_services = */ true, NetLogWithSource()));
  1155. EXPECT_FALSE(waiter.stream_done());
  1156. // Confirm a stream has been created by asserting that a new session
  1157. // has been created. (The stream is only created at the SPDY level on
  1158. // first write, which happens after the request has returned a stream).
  1159. ASSERT_EQ(1, GetSpdySessionCount(session.get()));
  1160. // Test to confirm that a SetPriority received after the stream is created
  1161. // but before the request returns it does not crash.
  1162. request->SetPriority(HIGHEST);
  1163. waiter.WaitForStream();
  1164. EXPECT_TRUE(waiter.stream_done());
  1165. ASSERT_TRUE(waiter.stream());
  1166. EXPECT_FALSE(waiter.websocket_stream());
  1167. }
  1168. TEST_F(HttpStreamFactoryTest, RequestHttpStreamOverSSL) {
  1169. SpdySessionDependencies session_deps(
  1170. ConfiguredProxyResolutionService::CreateDirect());
  1171. MockRead mock_read(ASYNC, OK);
  1172. StaticSocketDataProvider socket_data(base::make_span(&mock_read, 1),
  1173. base::span<MockWrite>());
  1174. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1175. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1176. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1177. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1178. std::unique_ptr<HttpNetworkSession> session(
  1179. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1180. // Now request a stream.
  1181. HttpRequestInfo request_info;
  1182. request_info.method = "GET";
  1183. request_info.url = GURL("https://www.google.com");
  1184. request_info.load_flags = 0;
  1185. request_info.traffic_annotation =
  1186. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1187. SSLConfig ssl_config;
  1188. StreamRequestWaiter waiter;
  1189. std::unique_ptr<HttpStreamRequest> request(
  1190. session->http_stream_factory()->RequestStream(
  1191. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1192. /* enable_ip_based_pooling = */ true,
  1193. /* enable_alternative_services = */ true, NetLogWithSource()));
  1194. waiter.WaitForStream();
  1195. EXPECT_TRUE(waiter.stream_done());
  1196. ASSERT_TRUE(nullptr != waiter.stream());
  1197. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1198. EXPECT_EQ(0, GetSpdySessionCount(session.get()));
  1199. EXPECT_EQ(
  1200. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  1201. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1202. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1203. }
  1204. TEST_F(HttpStreamFactoryTest, RequestHttpStreamOverProxy) {
  1205. SpdySessionDependencies session_deps(
  1206. ConfiguredProxyResolutionService::CreateFixedForTest(
  1207. "myproxy:8888", TRAFFIC_ANNOTATION_FOR_TESTS));
  1208. StaticSocketDataProvider socket_data;
  1209. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1210. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1211. std::unique_ptr<HttpNetworkSession> session(
  1212. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1213. // Now request a stream. It should succeed using the second proxy in the
  1214. // list.
  1215. HttpRequestInfo request_info;
  1216. request_info.method = "GET";
  1217. request_info.url = GURL("http://www.google.com");
  1218. request_info.load_flags = 0;
  1219. request_info.traffic_annotation =
  1220. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1221. SSLConfig ssl_config;
  1222. StreamRequestWaiter waiter;
  1223. std::unique_ptr<HttpStreamRequest> request(
  1224. session->http_stream_factory()->RequestStream(
  1225. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1226. /* enable_ip_based_pooling = */ true,
  1227. /* enable_alternative_services = */ true, NetLogWithSource()));
  1228. waiter.WaitForStream();
  1229. EXPECT_TRUE(waiter.stream_done());
  1230. ASSERT_TRUE(nullptr != waiter.stream());
  1231. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1232. EXPECT_EQ(0, GetSpdySessionCount(session.get()));
  1233. EXPECT_EQ(
  1234. 0, GetSocketPoolGroupCount(session->GetSocketPool(
  1235. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1236. EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPool(
  1237. HttpNetworkSession::NORMAL_SOCKET_POOL,
  1238. ProxyServer(ProxyServer::SCHEME_HTTP,
  1239. HostPortPair("myproxy", 8888)))));
  1240. EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPool(
  1241. HttpNetworkSession::NORMAL_SOCKET_POOL,
  1242. ProxyServer(ProxyServer::SCHEME_HTTPS,
  1243. HostPortPair("myproxy", 8888)))));
  1244. EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPool(
  1245. HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
  1246. ProxyServer(ProxyServer::SCHEME_HTTP,
  1247. HostPortPair("myproxy", 8888)))));
  1248. EXPECT_FALSE(waiter.used_proxy_info().is_direct());
  1249. }
  1250. TEST_F(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStream) {
  1251. SpdySessionDependencies session_deps(
  1252. ConfiguredProxyResolutionService::CreateDirect());
  1253. StaticSocketDataProvider socket_data;
  1254. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1255. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1256. std::unique_ptr<HttpNetworkSession> session(
  1257. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1258. // Now request a stream.
  1259. HttpRequestInfo request_info;
  1260. request_info.method = "GET";
  1261. request_info.url = GURL("ws://www.google.com");
  1262. request_info.load_flags = 0;
  1263. request_info.traffic_annotation =
  1264. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1265. SSLConfig ssl_config;
  1266. StreamRequestWaiter waiter;
  1267. WebSocketStreamCreateHelper create_helper;
  1268. std::unique_ptr<HttpStreamRequest> request(
  1269. session->http_stream_factory()->RequestWebSocketHandshakeStream(
  1270. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1271. &create_helper,
  1272. /* enable_ip_based_pooling = */ true,
  1273. /* enable_alternative_services = */ true, NetLogWithSource()));
  1274. waiter.WaitForStream();
  1275. EXPECT_TRUE(waiter.stream_done());
  1276. EXPECT_TRUE(nullptr == waiter.stream());
  1277. ASSERT_TRUE(nullptr != waiter.websocket_stream());
  1278. EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
  1279. waiter.websocket_stream()->type());
  1280. EXPECT_EQ(
  1281. 0, GetSocketPoolGroupCount(session->GetSocketPool(
  1282. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1283. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1284. }
  1285. TEST_F(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverSSL) {
  1286. SpdySessionDependencies session_deps(
  1287. ConfiguredProxyResolutionService::CreateDirect());
  1288. MockRead mock_read(ASYNC, OK);
  1289. StaticSocketDataProvider socket_data(base::make_span(&mock_read, 1),
  1290. base::span<MockWrite>());
  1291. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1292. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1293. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1294. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1295. std::unique_ptr<HttpNetworkSession> session(
  1296. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1297. // Now request a stream.
  1298. HttpRequestInfo request_info;
  1299. request_info.method = "GET";
  1300. request_info.url = GURL("wss://www.google.com");
  1301. request_info.load_flags = 0;
  1302. request_info.traffic_annotation =
  1303. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1304. SSLConfig ssl_config;
  1305. StreamRequestWaiter waiter;
  1306. WebSocketStreamCreateHelper create_helper;
  1307. std::unique_ptr<HttpStreamRequest> request(
  1308. session->http_stream_factory()->RequestWebSocketHandshakeStream(
  1309. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1310. &create_helper,
  1311. /* enable_ip_based_pooling = */ true,
  1312. /* enable_alternative_services = */ true, NetLogWithSource()));
  1313. waiter.WaitForStream();
  1314. EXPECT_TRUE(waiter.stream_done());
  1315. EXPECT_TRUE(nullptr == waiter.stream());
  1316. ASSERT_TRUE(nullptr != waiter.websocket_stream());
  1317. EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
  1318. waiter.websocket_stream()->type());
  1319. EXPECT_EQ(
  1320. 0, GetSocketPoolGroupCount(session->GetSocketPool(
  1321. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1322. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1323. }
  1324. TEST_F(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverProxy) {
  1325. SpdySessionDependencies session_deps(
  1326. ConfiguredProxyResolutionService::CreateFixedForTest(
  1327. "myproxy:8888", TRAFFIC_ANNOTATION_FOR_TESTS));
  1328. MockRead reads[] = {
  1329. MockRead(SYNCHRONOUS, "HTTP/1.0 200 Connection established\r\n\r\n")};
  1330. StaticSocketDataProvider socket_data(reads, base::span<MockWrite>());
  1331. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1332. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1333. std::unique_ptr<HttpNetworkSession> session(
  1334. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1335. // Now request a stream.
  1336. HttpRequestInfo request_info;
  1337. request_info.method = "GET";
  1338. request_info.url = GURL("ws://www.google.com");
  1339. request_info.load_flags = 0;
  1340. request_info.traffic_annotation =
  1341. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1342. SSLConfig ssl_config;
  1343. StreamRequestWaiter waiter;
  1344. WebSocketStreamCreateHelper create_helper;
  1345. std::unique_ptr<HttpStreamRequest> request(
  1346. session->http_stream_factory()->RequestWebSocketHandshakeStream(
  1347. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1348. &create_helper,
  1349. /* enable_ip_based_pooling = */ true,
  1350. /* enable_alternative_services = */ true, NetLogWithSource()));
  1351. waiter.WaitForStream();
  1352. EXPECT_TRUE(waiter.stream_done());
  1353. EXPECT_TRUE(nullptr == waiter.stream());
  1354. ASSERT_TRUE(nullptr != waiter.websocket_stream());
  1355. EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
  1356. waiter.websocket_stream()->type());
  1357. EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPool(
  1358. HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
  1359. ProxyServer::Direct())));
  1360. EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPool(
  1361. HttpNetworkSession::NORMAL_SOCKET_POOL,
  1362. ProxyServer(ProxyServer::SCHEME_HTTP,
  1363. HostPortPair("myproxy", 8888)))));
  1364. EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPool(
  1365. HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
  1366. ProxyServer(ProxyServer::SCHEME_HTTP,
  1367. HostPortPair("myproxy", 8888)))));
  1368. EXPECT_FALSE(waiter.used_proxy_info().is_direct());
  1369. }
  1370. TEST_F(HttpStreamFactoryTest, RequestSpdyHttpStreamHttpsURL) {
  1371. SpdySessionDependencies session_deps(
  1372. ConfiguredProxyResolutionService::CreateDirect());
  1373. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  1374. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  1375. base::span<MockWrite>());
  1376. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1377. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1378. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1379. ssl_socket_data.next_proto = kProtoHTTP2;
  1380. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1381. HostPortPair host_port_pair("www.google.com", 443);
  1382. std::unique_ptr<HttpNetworkSession> session(
  1383. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1384. // Now request a stream.
  1385. HttpRequestInfo request_info;
  1386. request_info.method = "GET";
  1387. request_info.url = GURL("https://www.google.com");
  1388. request_info.load_flags = 0;
  1389. request_info.traffic_annotation =
  1390. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1391. SSLConfig ssl_config;
  1392. StreamRequestWaiter waiter;
  1393. std::unique_ptr<HttpStreamRequest> request(
  1394. session->http_stream_factory()->RequestStream(
  1395. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1396. /* enable_ip_based_pooling = */ true,
  1397. /* enable_alternative_services = */ true, NetLogWithSource()));
  1398. waiter.WaitForStream();
  1399. EXPECT_TRUE(waiter.stream_done());
  1400. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1401. ASSERT_TRUE(nullptr != waiter.stream());
  1402. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  1403. EXPECT_EQ(
  1404. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  1405. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1406. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1407. }
  1408. TEST_F(HttpStreamFactoryTest, RequestSpdyHttpStreamHttpURL) {
  1409. url::SchemeHostPort scheme_host_port("http", "myproxy.org", 443);
  1410. auto session_deps = std::make_unique<SpdySessionDependencies>(
  1411. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  1412. "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS));
  1413. std::unique_ptr<ProxyResolutionService> proxy_resolution_service =
  1414. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  1415. "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS);
  1416. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  1417. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  1418. base::span<MockWrite>());
  1419. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1420. session_deps->socket_factory->AddSocketDataProvider(&socket_data);
  1421. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1422. ssl_socket_data.next_proto = kProtoHTTP2;
  1423. session_deps->socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1424. session_deps->proxy_resolution_service = std::move(proxy_resolution_service);
  1425. std::unique_ptr<HttpNetworkSession> session(
  1426. SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
  1427. HttpServerProperties* http_server_properties =
  1428. session->spdy_session_pool()->http_server_properties();
  1429. EXPECT_FALSE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1430. NetworkIsolationKey()));
  1431. // Now request a stream.
  1432. HttpRequestInfo request_info;
  1433. request_info.method = "GET";
  1434. request_info.url = GURL("http://www.google.com");
  1435. request_info.load_flags = 0;
  1436. request_info.traffic_annotation =
  1437. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1438. SSLConfig ssl_config;
  1439. StreamRequestWaiter waiter;
  1440. std::unique_ptr<HttpStreamRequest> request(
  1441. session->http_stream_factory()->RequestStream(
  1442. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1443. /* enable_ip_based_pooling = */ true,
  1444. /* enable_alternative_services = */ true, NetLogWithSource()));
  1445. waiter.WaitForStream();
  1446. EXPECT_TRUE(waiter.stream_done());
  1447. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1448. ASSERT_TRUE(nullptr != waiter.stream());
  1449. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  1450. EXPECT_EQ(
  1451. 0, GetSocketPoolGroupCount(session->GetSocketPool(
  1452. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1453. EXPECT_FALSE(waiter.used_proxy_info().is_direct());
  1454. EXPECT_TRUE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1455. NetworkIsolationKey()));
  1456. }
  1457. // Same as above, but checks HttpServerProperties is updated using the correct
  1458. // NetworkIsolationKey. When/if NetworkIsolationKey is enabled by default, this
  1459. // should probably be merged into the above test.
  1460. TEST_F(HttpStreamFactoryTest,
  1461. RequestSpdyHttpStreamHttpURLWithNetworkIsolationKey) {
  1462. const SchemefulSite kSite1(GURL("https://foo.test/"));
  1463. const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);
  1464. const SchemefulSite kSite2(GURL("https://bar.test/"));
  1465. const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
  1466. base::test::ScopedFeatureList feature_list;
  1467. feature_list.InitAndEnableFeature(
  1468. features::kPartitionHttpServerPropertiesByNetworkIsolationKey);
  1469. url::SchemeHostPort scheme_host_port("http", "myproxy.org", 443);
  1470. auto session_deps = std::make_unique<SpdySessionDependencies>(
  1471. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  1472. "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS));
  1473. std::unique_ptr<ProxyResolutionService> proxy_resolution_service =
  1474. ConfiguredProxyResolutionService::CreateFixedFromPacResultForTest(
  1475. "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS);
  1476. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  1477. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  1478. base::span<MockWrite>());
  1479. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1480. session_deps->socket_factory->AddSocketDataProvider(&socket_data);
  1481. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1482. ssl_socket_data.next_proto = kProtoHTTP2;
  1483. session_deps->socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1484. session_deps->proxy_resolution_service = std::move(proxy_resolution_service);
  1485. std::unique_ptr<HttpNetworkSession> session(
  1486. SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
  1487. HttpServerProperties* http_server_properties =
  1488. session->spdy_session_pool()->http_server_properties();
  1489. EXPECT_FALSE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1490. kNetworkIsolationKey1));
  1491. // Now request a stream.
  1492. HttpRequestInfo request_info;
  1493. request_info.method = "GET";
  1494. request_info.url = GURL("http://www.google.com");
  1495. request_info.load_flags = 0;
  1496. request_info.network_isolation_key = kNetworkIsolationKey1;
  1497. request_info.traffic_annotation =
  1498. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1499. SSLConfig ssl_config;
  1500. StreamRequestWaiter waiter;
  1501. std::unique_ptr<HttpStreamRequest> request(
  1502. session->http_stream_factory()->RequestStream(
  1503. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1504. /* enable_ip_based_pooling = */ true,
  1505. /* enable_alternative_services = */ true, NetLogWithSource()));
  1506. waiter.WaitForStream();
  1507. EXPECT_TRUE(waiter.stream_done());
  1508. EXPECT_TRUE(nullptr == waiter.websocket_stream());
  1509. ASSERT_TRUE(nullptr != waiter.stream());
  1510. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  1511. EXPECT_EQ(
  1512. 0, GetSocketPoolGroupCount(session->GetSocketPool(
  1513. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1514. EXPECT_FALSE(waiter.used_proxy_info().is_direct());
  1515. EXPECT_TRUE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1516. kNetworkIsolationKey1));
  1517. // Other NetworkIsolationKeys should not be recorded as supporting SPDY.
  1518. EXPECT_FALSE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1519. NetworkIsolationKey()));
  1520. EXPECT_FALSE(http_server_properties->GetSupportsSpdy(scheme_host_port,
  1521. kNetworkIsolationKey2));
  1522. }
  1523. // Tests that when a new SpdySession is established, duplicated idle H2 sockets
  1524. // to the same server are closed.
  1525. TEST_F(HttpStreamFactoryTest, NewSpdySessionCloseIdleH2Sockets) {
  1526. SpdySessionDependencies session_deps(
  1527. ConfiguredProxyResolutionService::CreateDirect());
  1528. const int kNumIdleSockets = 4;
  1529. MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
  1530. std::vector<std::unique_ptr<SequencedSocketData>> providers;
  1531. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1532. ssl_socket_data.next_proto = kProtoHTTP2;
  1533. for (int i = 0; i < kNumIdleSockets; i++) {
  1534. auto provider =
  1535. std::make_unique<SequencedSocketData>(reads, base::span<MockWrite>());
  1536. provider->set_connect_data(MockConnect(ASYNC, OK));
  1537. session_deps.socket_factory->AddSocketDataProvider(provider.get());
  1538. providers.push_back(std::move(provider));
  1539. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1540. }
  1541. std::unique_ptr<HttpNetworkSession> session(
  1542. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1543. url::SchemeHostPort destination(url::kHttpsScheme, "www.google.com", 443);
  1544. // Create some HTTP/2 sockets.
  1545. std::vector<std::unique_ptr<ClientSocketHandle>> handles;
  1546. for (size_t i = 0; i < kNumIdleSockets; i++) {
  1547. auto connection = std::make_unique<ClientSocketHandle>();
  1548. TestCompletionCallback callback;
  1549. auto ssl_config_for_origin = std::make_unique<SSLConfig>();
  1550. ssl_config_for_origin->alpn_protos = session->GetAlpnProtos();
  1551. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  1552. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  1553. std::move(ssl_config_for_origin),
  1554. /*ssl_config_for_proxy=*/nullptr);
  1555. ClientSocketPool::GroupId group_id(
  1556. destination, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(),
  1557. SecureDnsPolicy::kAllow);
  1558. int rv = connection->Init(
  1559. group_id, socket_params, absl::nullopt /* proxy_annotation_tag */,
  1560. MEDIUM, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
  1561. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  1562. session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  1563. ProxyServer::Direct()),
  1564. NetLogWithSource());
  1565. rv = callback.GetResult(rv);
  1566. handles.push_back(std::move(connection));
  1567. }
  1568. // Releases handles now, and these sockets should go into the socket pool.
  1569. handles.clear();
  1570. EXPECT_EQ(kNumIdleSockets,
  1571. session
  1572. ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  1573. ProxyServer::Direct())
  1574. ->IdleSocketCount());
  1575. // Request two streams at once and make sure they use the same connection.
  1576. HttpRequestInfo request_info;
  1577. request_info.method = "GET";
  1578. request_info.url = GURL("https://www.google.com");
  1579. request_info.load_flags = 0;
  1580. request_info.traffic_annotation =
  1581. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1582. SSLConfig ssl_config;
  1583. StreamRequestWaiter waiter1;
  1584. StreamRequestWaiter waiter2;
  1585. std::unique_ptr<HttpStreamRequest> request1(
  1586. session->http_stream_factory()->RequestStream(
  1587. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  1588. /* enable_ip_based_pooling = */ true,
  1589. /* enable_alternative_services = */ true, NetLogWithSource()));
  1590. std::unique_ptr<HttpStreamRequest> request2(
  1591. session->http_stream_factory()->RequestStream(
  1592. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  1593. /* enable_ip_based_pooling = */ true,
  1594. /* enable_alternative_services = */ true, NetLogWithSource()));
  1595. waiter1.WaitForStream();
  1596. waiter2.WaitForStream();
  1597. EXPECT_TRUE(waiter1.stream_done());
  1598. EXPECT_TRUE(waiter2.stream_done());
  1599. ASSERT_NE(nullptr, waiter1.stream());
  1600. ASSERT_NE(nullptr, waiter2.stream());
  1601. ASSERT_NE(waiter1.stream(), waiter2.stream());
  1602. // Establishing the SpdySession will close idle H2 sockets.
  1603. EXPECT_EQ(0, session
  1604. ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  1605. ProxyServer::Direct())
  1606. ->IdleSocketCount());
  1607. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  1608. }
  1609. // Regression test for https://crbug.com/706974.
  1610. TEST_F(HttpStreamFactoryTest, TwoSpdyConnects) {
  1611. SpdySessionDependencies session_deps(
  1612. ConfiguredProxyResolutionService::CreateDirect());
  1613. SSLSocketDataProvider ssl_socket_data0(ASYNC, OK);
  1614. ssl_socket_data0.next_proto = kProtoHTTP2;
  1615. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data0);
  1616. MockRead reads0[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
  1617. SequencedSocketData data0(reads0, base::span<MockWrite>());
  1618. data0.set_connect_data(MockConnect(ASYNC, OK));
  1619. session_deps.socket_factory->AddSocketDataProvider(&data0);
  1620. SSLSocketDataProvider ssl_socket_data1(ASYNC, OK);
  1621. ssl_socket_data1.next_proto = kProtoHTTP2;
  1622. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data1);
  1623. SequencedSocketData data1;
  1624. data1.set_connect_data(MockConnect(ASYNC, OK));
  1625. session_deps.socket_factory->AddSocketDataProvider(&data1);
  1626. std::unique_ptr<HttpNetworkSession> session =
  1627. SpdySessionDependencies::SpdyCreateSession(&session_deps);
  1628. HttpRequestInfo request_info;
  1629. request_info.method = "GET";
  1630. request_info.url = GURL("https://www.google.com");
  1631. request_info.load_flags = 0;
  1632. request_info.traffic_annotation =
  1633. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1634. SSLConfig ssl_config;
  1635. // Request two streams at once and make sure they use the same connection.
  1636. StreamRequestWaiter waiter1;
  1637. std::unique_ptr<HttpStreamRequest> request1 =
  1638. session->http_stream_factory()->RequestStream(
  1639. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  1640. /* enable_ip_based_pooling = */ true,
  1641. /* enable_alternative_services = */ true, NetLogWithSource());
  1642. StreamRequestWaiter waiter2;
  1643. std::unique_ptr<HttpStreamRequest> request2 =
  1644. session->http_stream_factory()->RequestStream(
  1645. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  1646. /* enable_ip_based_pooling = */ true,
  1647. /* enable_alternative_services = */ true, NetLogWithSource());
  1648. waiter1.WaitForStream();
  1649. waiter2.WaitForStream();
  1650. EXPECT_TRUE(waiter1.stream_done());
  1651. EXPECT_TRUE(waiter2.stream_done());
  1652. ASSERT_NE(nullptr, waiter1.stream());
  1653. ASSERT_NE(nullptr, waiter2.stream());
  1654. ASSERT_NE(waiter1.stream(), waiter2.stream());
  1655. // Establishing the SpdySession will close the extra H2 socket.
  1656. EXPECT_EQ(0, session
  1657. ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  1658. ProxyServer::Direct())
  1659. ->IdleSocketCount());
  1660. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  1661. EXPECT_TRUE(data0.AllReadDataConsumed());
  1662. EXPECT_TRUE(data1.AllReadDataConsumed());
  1663. }
  1664. TEST_F(HttpStreamFactoryTest, RequestBidirectionalStreamImpl) {
  1665. SpdySessionDependencies session_deps(
  1666. ConfiguredProxyResolutionService::CreateDirect());
  1667. MockRead mock_read(ASYNC, OK);
  1668. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  1669. base::span<MockWrite>());
  1670. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  1671. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  1672. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  1673. ssl_socket_data.next_proto = kProtoHTTP2;
  1674. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  1675. std::unique_ptr<HttpNetworkSession> session(
  1676. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  1677. // Now request a stream.
  1678. HttpRequestInfo request_info;
  1679. request_info.method = "GET";
  1680. request_info.url = GURL("https://www.google.com");
  1681. request_info.load_flags = 0;
  1682. request_info.traffic_annotation =
  1683. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1684. SSLConfig ssl_config;
  1685. StreamRequestWaiter waiter;
  1686. std::unique_ptr<HttpStreamRequest> request(
  1687. session->http_stream_factory()->RequestBidirectionalStreamImpl(
  1688. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1689. /* enable_ip_based_pooling = */ true,
  1690. /* enable_alternative_services = */ true, NetLogWithSource()));
  1691. waiter.WaitForStream();
  1692. EXPECT_TRUE(waiter.stream_done());
  1693. EXPECT_FALSE(waiter.websocket_stream());
  1694. ASSERT_FALSE(waiter.stream());
  1695. ASSERT_TRUE(waiter.bidirectional_stream_impl());
  1696. EXPECT_EQ(
  1697. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  1698. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1699. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1700. }
  1701. struct TestParams {
  1702. quic::ParsedQuicVersion version;
  1703. bool client_headers_include_h2_stream_dependency;
  1704. };
  1705. // Used by ::testing::PrintToStringParamName().
  1706. std::string PrintToString(const TestParams& p) {
  1707. return base::StrCat(
  1708. {ParsedQuicVersionToString(p.version), "_",
  1709. (p.client_headers_include_h2_stream_dependency ? "" : "No"),
  1710. "Dependency"});
  1711. }
  1712. std::vector<TestParams> GetTestParams() {
  1713. std::vector<TestParams> params;
  1714. quic::ParsedQuicVersionVector all_supported_versions =
  1715. quic::AllSupportedVersions();
  1716. for (const auto& version : all_supported_versions) {
  1717. params.push_back(TestParams{version, false});
  1718. params.push_back(TestParams{version, true});
  1719. }
  1720. return params;
  1721. }
  1722. class HttpStreamFactoryBidirectionalQuicTest
  1723. : public TestWithTaskEnvironment,
  1724. public ::testing::WithParamInterface<TestParams> {
  1725. protected:
  1726. HttpStreamFactoryBidirectionalQuicTest()
  1727. : default_url_(kDefaultUrl),
  1728. version_(GetParam().version),
  1729. client_headers_include_h2_stream_dependency_(
  1730. GetParam().client_headers_include_h2_stream_dependency),
  1731. client_packet_maker_(version_,
  1732. quic::QuicUtils::CreateRandomConnectionId(
  1733. quic_context_.random_generator()),
  1734. quic_context_.clock(),
  1735. "www.example.org",
  1736. quic::Perspective::IS_CLIENT,
  1737. client_headers_include_h2_stream_dependency_),
  1738. server_packet_maker_(version_,
  1739. quic::QuicUtils::CreateRandomConnectionId(
  1740. quic_context_.random_generator()),
  1741. quic_context_.clock(),
  1742. "www.example.org",
  1743. quic::Perspective::IS_SERVER,
  1744. false),
  1745. proxy_resolution_service_(
  1746. ConfiguredProxyResolutionService::CreateDirect()),
  1747. ssl_config_service_(std::make_unique<SSLConfigServiceDefaults>()) {
  1748. FLAGS_quic_enable_http3_grease_randomness = false;
  1749. quic_context_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
  1750. quic::QuicEnableVersion(version_);
  1751. }
  1752. void TearDown() override { session_.reset(); }
  1753. // Disable bidirectional stream over QUIC. This should be invoked before
  1754. // Initialize().
  1755. void DisableQuicBidirectionalStream() {
  1756. quic_context_.params()->disable_bidirectional_streams = true;
  1757. }
  1758. void Initialize() {
  1759. params_.enable_quic = true;
  1760. quic_context_.params()->supported_versions =
  1761. quic::test::SupportedVersions(version_);
  1762. quic_context_.params()->headers_include_h2_stream_dependency =
  1763. client_headers_include_h2_stream_dependency_;
  1764. HttpNetworkSessionContext session_context;
  1765. session_context.http_server_properties = &http_server_properties_;
  1766. session_context.quic_context = &quic_context_;
  1767. // Load a certificate that is valid for *.example.org
  1768. scoped_refptr<X509Certificate> test_cert(
  1769. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
  1770. EXPECT_TRUE(test_cert.get());
  1771. verify_details_.cert_verify_result.verified_cert = test_cert;
  1772. verify_details_.cert_verify_result.is_issued_by_known_root = true;
  1773. crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
  1774. crypto_client_stream_factory_.set_handshake_mode(
  1775. MockCryptoClientStream::CONFIRM_HANDSHAKE);
  1776. session_context.cert_verifier = &cert_verifier_;
  1777. session_context.quic_crypto_client_stream_factory =
  1778. &crypto_client_stream_factory_;
  1779. session_context.transport_security_state = &transport_security_state_;
  1780. session_context.ct_policy_enforcer = &ct_policy_enforcer_;
  1781. session_context.host_resolver = &host_resolver_;
  1782. session_context.proxy_resolution_service = proxy_resolution_service_.get();
  1783. session_context.ssl_config_service = ssl_config_service_.get();
  1784. session_context.client_socket_factory = &socket_factory_;
  1785. session_ = std::make_unique<HttpNetworkSession>(params_, session_context);
  1786. session_->quic_stream_factory()
  1787. ->set_is_quic_known_to_work_on_current_network(true);
  1788. }
  1789. void AddQuicAlternativeService(const url::SchemeHostPort& request_url,
  1790. const std::string& alternative_destination) {
  1791. const AlternativeService alternative_service(kProtoQUIC,
  1792. alternative_destination, 443);
  1793. base::Time expiration = base::Time::Now() + base::Days(1);
  1794. http_server_properties_.SetQuicAlternativeService(
  1795. request_url, NetworkIsolationKey(), alternative_service, expiration,
  1796. session_->context().quic_context->params()->supported_versions);
  1797. }
  1798. void AddQuicAlternativeService() {
  1799. AddQuicAlternativeService(url::SchemeHostPort(default_url_),
  1800. "www.example.org");
  1801. }
  1802. test::QuicTestPacketMaker& client_packet_maker() {
  1803. return client_packet_maker_;
  1804. }
  1805. test::QuicTestPacketMaker& server_packet_maker() {
  1806. return server_packet_maker_;
  1807. }
  1808. MockTaggingClientSocketFactory& socket_factory() { return socket_factory_; }
  1809. HttpNetworkSession* session() { return session_.get(); }
  1810. const GURL default_url_;
  1811. quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
  1812. return quic::test::GetNthClientInitiatedBidirectionalStreamId(
  1813. version_.transport_version, n);
  1814. }
  1815. quic::ParsedQuicVersion version() const { return version_; }
  1816. MockHostResolver* host_resolver() { return &host_resolver_; }
  1817. private:
  1818. quic::test::QuicFlagSaver saver_;
  1819. const quic::ParsedQuicVersion version_;
  1820. const bool client_headers_include_h2_stream_dependency_;
  1821. MockQuicContext quic_context_;
  1822. test::QuicTestPacketMaker client_packet_maker_;
  1823. test::QuicTestPacketMaker server_packet_maker_;
  1824. MockTaggingClientSocketFactory socket_factory_;
  1825. std::unique_ptr<HttpNetworkSession> session_;
  1826. MockCertVerifier cert_verifier_;
  1827. ProofVerifyDetailsChromium verify_details_;
  1828. MockCryptoClientStreamFactory crypto_client_stream_factory_;
  1829. HttpServerProperties http_server_properties_;
  1830. TransportSecurityState transport_security_state_;
  1831. DefaultCTPolicyEnforcer ct_policy_enforcer_;
  1832. MockHostResolver host_resolver_{
  1833. /*default_result=*/
  1834. MockHostResolverBase::RuleResolver::GetLocalhostResult()};
  1835. std::unique_ptr<ProxyResolutionService> proxy_resolution_service_;
  1836. std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_;
  1837. HttpNetworkSessionParams params_;
  1838. };
  1839. INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
  1840. HttpStreamFactoryBidirectionalQuicTest,
  1841. ::testing::ValuesIn(GetTestParams()),
  1842. ::testing::PrintToStringParamName());
  1843. TEST_P(HttpStreamFactoryBidirectionalQuicTest,
  1844. RequestBidirectionalStreamImplQuicAlternative) {
  1845. MockQuicData mock_quic_data(version());
  1846. // When using IETF QUIC, set priority to default value so that
  1847. // QuicTestPacketMaker::MakeRequestHeadersPacket() does not add mock
  1848. // PRIORITY_UPDATE frame, which BidirectionalStreamQuicImpl currently does not
  1849. // send.
  1850. // TODO(https://crbug.com/1059250): Implement PRIORITY_UPDATE in
  1851. // BidirectionalStreamQuicImpl.
  1852. spdy::SpdyPriority priority =
  1853. ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
  1854. size_t spdy_headers_frame_length;
  1855. int packet_num = 1;
  1856. if (VersionUsesHttp3(version().transport_version)) {
  1857. mock_quic_data.AddWrite(
  1858. client_packet_maker().MakeInitialSettingsPacket(packet_num++));
  1859. }
  1860. mock_quic_data.AddWrite(client_packet_maker().MakeRequestHeadersPacket(
  1861. packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
  1862. /*should_include_version=*/true,
  1863. /*fin=*/true, priority,
  1864. client_packet_maker().GetRequestHeaders("GET", "https", "/"),
  1865. /*parent_stream_id=*/0, &spdy_headers_frame_length));
  1866. size_t spdy_response_headers_frame_length;
  1867. mock_quic_data.AddRead(server_packet_maker().MakeResponseHeadersPacket(
  1868. 1, GetNthClientInitiatedBidirectionalStreamId(0),
  1869. /*should_include_version=*/false,
  1870. /*fin=*/true, server_packet_maker().GetResponseHeaders("200"),
  1871. &spdy_response_headers_frame_length));
  1872. mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
  1873. mock_quic_data.AddSocketDataToFactory(&socket_factory());
  1874. // Add hanging data for http job.
  1875. auto hanging_data = std::make_unique<StaticSocketDataProvider>();
  1876. MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
  1877. hanging_data->set_connect_data(hanging_connect);
  1878. socket_factory().AddSocketDataProvider(hanging_data.get());
  1879. SSLSocketDataProvider ssl_data(ASYNC, OK);
  1880. socket_factory().AddSSLSocketDataProvider(&ssl_data);
  1881. // Set up QUIC as alternative_service.
  1882. Initialize();
  1883. AddQuicAlternativeService();
  1884. // Now request a stream.
  1885. SSLConfig ssl_config;
  1886. HttpRequestInfo request_info;
  1887. request_info.method = "GET";
  1888. request_info.url = default_url_;
  1889. request_info.load_flags = 0;
  1890. request_info.traffic_annotation =
  1891. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1892. StreamRequestWaiter waiter;
  1893. std::unique_ptr<HttpStreamRequest> request(
  1894. session()->http_stream_factory()->RequestBidirectionalStreamImpl(
  1895. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1896. /* enable_ip_based_pooling = */ true,
  1897. /* enable_alternative_services = */ true, NetLogWithSource()));
  1898. waiter.WaitForStream();
  1899. EXPECT_TRUE(waiter.stream_done());
  1900. EXPECT_FALSE(waiter.websocket_stream());
  1901. ASSERT_FALSE(waiter.stream());
  1902. ASSERT_TRUE(waiter.bidirectional_stream_impl());
  1903. BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl();
  1904. BidirectionalStreamRequestInfo bidi_request_info;
  1905. bidi_request_info.method = "GET";
  1906. bidi_request_info.url = default_url_;
  1907. bidi_request_info.end_stream_on_headers = true;
  1908. bidi_request_info.priority = LOWEST;
  1909. TestBidirectionalDelegate delegate;
  1910. stream_impl->Start(&bidi_request_info, NetLogWithSource(),
  1911. /*send_request_headers_automatically=*/true, &delegate,
  1912. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  1913. delegate.WaitUntilDone();
  1914. scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(1);
  1915. EXPECT_THAT(stream_impl->ReadData(buffer.get(), 1), IsOk());
  1916. EXPECT_EQ(kProtoQUIC, stream_impl->GetProtocol());
  1917. EXPECT_EQ("200", delegate.response_headers().find(":status")->second);
  1918. EXPECT_EQ(
  1919. 0, GetSocketPoolGroupCount(session()->GetSocketPool(
  1920. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  1921. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  1922. }
  1923. // Tests that when QUIC is not enabled for bidirectional streaming, HTTP/2 is
  1924. // used instead.
  1925. TEST_P(HttpStreamFactoryBidirectionalQuicTest,
  1926. RequestBidirectionalStreamImplQuicNotEnabled) {
  1927. // Make the http job fail.
  1928. auto http_job_data = std::make_unique<StaticSocketDataProvider>();
  1929. MockConnect failed_connect(ASYNC, ERR_CONNECTION_REFUSED);
  1930. http_job_data->set_connect_data(failed_connect);
  1931. socket_factory().AddSocketDataProvider(http_job_data.get());
  1932. SSLSocketDataProvider ssl_data(ASYNC, OK);
  1933. socket_factory().AddSSLSocketDataProvider(&ssl_data);
  1934. // Set up QUIC as alternative_service.
  1935. DisableQuicBidirectionalStream();
  1936. Initialize();
  1937. AddQuicAlternativeService();
  1938. // Now request a stream.
  1939. SSLConfig ssl_config;
  1940. HttpRequestInfo request_info;
  1941. request_info.method = "GET";
  1942. request_info.url = default_url_;
  1943. request_info.load_flags = 0;
  1944. request_info.traffic_annotation =
  1945. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  1946. StreamRequestWaiter waiter;
  1947. std::unique_ptr<HttpStreamRequest> request(
  1948. session()->http_stream_factory()->RequestBidirectionalStreamImpl(
  1949. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  1950. /* enable_ip_based_pooling = */ true,
  1951. /* enable_alternative_services = */ true, NetLogWithSource()));
  1952. waiter.WaitForStream();
  1953. EXPECT_TRUE(waiter.stream_done());
  1954. EXPECT_FALSE(waiter.websocket_stream());
  1955. ASSERT_FALSE(waiter.stream());
  1956. ASSERT_FALSE(waiter.bidirectional_stream_impl());
  1957. // Since the alternative service job is not started, we will get the error
  1958. // from the http job.
  1959. ASSERT_THAT(waiter.error_status(), IsError(ERR_CONNECTION_REFUSED));
  1960. }
  1961. // Tests that if Http job fails, but Quic job succeeds, we return
  1962. // BidirectionalStreamQuicImpl.
  1963. TEST_P(HttpStreamFactoryBidirectionalQuicTest,
  1964. RequestBidirectionalStreamImplHttpJobFailsQuicJobSucceeds) {
  1965. // Set up Quic data.
  1966. MockQuicData mock_quic_data(version());
  1967. // When using IETF QUIC, set priority to default value so that
  1968. // QuicTestPacketMaker::MakeRequestHeadersPacket() does not add mock
  1969. // PRIORITY_UPDATE frame, which BidirectionalStreamQuicImpl currently does not
  1970. // send.
  1971. // TODO(https://crbug.com/1059250): Implement PRIORITY_UPDATE in
  1972. // BidirectionalStreamQuicImpl.
  1973. spdy::SpdyPriority priority =
  1974. ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
  1975. size_t spdy_headers_frame_length;
  1976. int packet_num = 1;
  1977. if (VersionUsesHttp3(version().transport_version)) {
  1978. mock_quic_data.AddWrite(
  1979. client_packet_maker().MakeInitialSettingsPacket(packet_num++));
  1980. }
  1981. mock_quic_data.AddWrite(client_packet_maker().MakeRequestHeadersPacket(
  1982. packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
  1983. /*should_include_version=*/true,
  1984. /*fin=*/true, priority,
  1985. client_packet_maker().GetRequestHeaders("GET", "https", "/"),
  1986. /*parent_stream_id=*/0, &spdy_headers_frame_length));
  1987. size_t spdy_response_headers_frame_length;
  1988. mock_quic_data.AddRead(server_packet_maker().MakeResponseHeadersPacket(
  1989. 1, GetNthClientInitiatedBidirectionalStreamId(0),
  1990. /*should_include_version=*/false,
  1991. /*fin=*/true, server_packet_maker().GetResponseHeaders("200"),
  1992. &spdy_response_headers_frame_length));
  1993. mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
  1994. mock_quic_data.AddSocketDataToFactory(&socket_factory());
  1995. // Make the http job fail.
  1996. auto http_job_data = std::make_unique<StaticSocketDataProvider>();
  1997. MockConnect failed_connect(ASYNC, ERR_CONNECTION_REFUSED);
  1998. http_job_data->set_connect_data(failed_connect);
  1999. socket_factory().AddSocketDataProvider(http_job_data.get());
  2000. SSLSocketDataProvider ssl_data(ASYNC, OK);
  2001. socket_factory().AddSSLSocketDataProvider(&ssl_data);
  2002. // Set up QUIC as alternative_service.
  2003. Initialize();
  2004. AddQuicAlternativeService();
  2005. // Now request a stream.
  2006. SSLConfig ssl_config;
  2007. HttpRequestInfo request_info;
  2008. request_info.method = "GET";
  2009. request_info.url = default_url_;
  2010. request_info.load_flags = 0;
  2011. request_info.traffic_annotation =
  2012. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2013. StreamRequestWaiter waiter;
  2014. std::unique_ptr<HttpStreamRequest> request(
  2015. session()->http_stream_factory()->RequestBidirectionalStreamImpl(
  2016. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  2017. /* enable_ip_based_pooling = */ true,
  2018. /* enable_alternative_services = */ true, NetLogWithSource()));
  2019. waiter.WaitForStream();
  2020. EXPECT_TRUE(waiter.stream_done());
  2021. EXPECT_FALSE(waiter.websocket_stream());
  2022. ASSERT_FALSE(waiter.stream());
  2023. ASSERT_TRUE(waiter.bidirectional_stream_impl());
  2024. BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl();
  2025. BidirectionalStreamRequestInfo bidi_request_info;
  2026. bidi_request_info.method = "GET";
  2027. bidi_request_info.url = default_url_;
  2028. bidi_request_info.end_stream_on_headers = true;
  2029. bidi_request_info.priority = LOWEST;
  2030. TestBidirectionalDelegate delegate;
  2031. stream_impl->Start(&bidi_request_info, NetLogWithSource(),
  2032. /*send_request_headers_automatically=*/true, &delegate,
  2033. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  2034. delegate.WaitUntilDone();
  2035. // Make sure the BidirectionalStream negotiated goes through QUIC.
  2036. scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(1);
  2037. EXPECT_THAT(stream_impl->ReadData(buffer.get(), 1), IsOk());
  2038. EXPECT_EQ(kProtoQUIC, stream_impl->GetProtocol());
  2039. EXPECT_EQ("200", delegate.response_headers().find(":status")->second);
  2040. // There is no Http2 socket pool.
  2041. EXPECT_EQ(
  2042. 0, GetSocketPoolGroupCount(session()->GetSocketPool(
  2043. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2044. EXPECT_TRUE(waiter.used_proxy_info().is_direct());
  2045. }
  2046. TEST_F(HttpStreamFactoryTest, RequestBidirectionalStreamImplFailure) {
  2047. SpdySessionDependencies session_deps(
  2048. ConfiguredProxyResolutionService::CreateDirect());
  2049. MockRead mock_read(ASYNC, OK);
  2050. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  2051. base::span<MockWrite>());
  2052. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  2053. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  2054. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  2055. // If HTTP/1 is used, BidirectionalStreamImpl should not be obtained.
  2056. ssl_socket_data.next_proto = kProtoHTTP11;
  2057. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  2058. std::unique_ptr<HttpNetworkSession> session(
  2059. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2060. // Now request a stream.
  2061. HttpRequestInfo request_info;
  2062. request_info.method = "GET";
  2063. request_info.url = GURL("https://www.google.com");
  2064. request_info.load_flags = 0;
  2065. request_info.traffic_annotation =
  2066. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2067. SSLConfig ssl_config;
  2068. StreamRequestWaiter waiter;
  2069. std::unique_ptr<HttpStreamRequest> request(
  2070. session->http_stream_factory()->RequestBidirectionalStreamImpl(
  2071. request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
  2072. /* enable_ip_based_pooling = */ true,
  2073. /* enable_alternative_services = */ true, NetLogWithSource()));
  2074. waiter.WaitForStream();
  2075. EXPECT_TRUE(waiter.stream_done());
  2076. ASSERT_THAT(waiter.error_status(), IsError(ERR_FAILED));
  2077. EXPECT_FALSE(waiter.websocket_stream());
  2078. ASSERT_FALSE(waiter.stream());
  2079. ASSERT_FALSE(waiter.bidirectional_stream_impl());
  2080. EXPECT_EQ(
  2081. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2082. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2083. }
  2084. #if BUILDFLAG(IS_ANDROID)
  2085. // Verify HttpStreamFactory::Job passes socket tag along properly and that
  2086. // SpdySessions have unique socket tags (e.g. one sessions should not be shared
  2087. // amongst streams with different socket tags).
  2088. TEST_F(HttpStreamFactoryTest, Tag) {
  2089. SpdySessionDependencies session_deps;
  2090. auto socket_factory = std::make_unique<MockTaggingClientSocketFactory>();
  2091. auto* socket_factory_ptr = socket_factory.get();
  2092. session_deps.socket_factory = std::move(socket_factory);
  2093. // Prepare for two HTTPS connects.
  2094. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  2095. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  2096. base::span<MockWrite>());
  2097. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  2098. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  2099. MockRead mock_read2(SYNCHRONOUS, ERR_IO_PENDING);
  2100. SequencedSocketData socket_data2(base::make_span(&mock_read2, 1),
  2101. base::span<MockWrite>());
  2102. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  2103. session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
  2104. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  2105. ssl_socket_data.ssl_info.cert =
  2106. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2107. ssl_socket_data.next_proto = kProtoHTTP2;
  2108. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  2109. SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
  2110. ssl_socket_data2.ssl_info.cert =
  2111. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2112. ssl_socket_data2.next_proto = kProtoHTTP2;
  2113. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data2);
  2114. std::unique_ptr<HttpNetworkSession> session(
  2115. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2116. // Prepare two different tags and corresponding HttpRequestInfos.
  2117. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  2118. HttpRequestInfo request_info1;
  2119. request_info1.method = "GET";
  2120. request_info1.url = GURL("https://example.org");
  2121. request_info1.load_flags = 0;
  2122. request_info1.socket_tag = tag1;
  2123. request_info1.traffic_annotation =
  2124. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2125. SocketTag tag2(getuid(), 0x87654321);
  2126. HttpRequestInfo request_info2 = request_info1;
  2127. request_info2.socket_tag = tag2;
  2128. request_info2.traffic_annotation =
  2129. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2130. // Verify one stream with one tag results in one session, group and
  2131. // socket.
  2132. SSLConfig ssl_config;
  2133. StreamRequestWaiter waiter1;
  2134. std::unique_ptr<HttpStreamRequest> request1(
  2135. session->http_stream_factory()->RequestStream(
  2136. request_info1, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2137. /* enable_ip_based_pooling = */ true,
  2138. /* enable_alternative_services = */ true, NetLogWithSource()));
  2139. waiter1.WaitForStream();
  2140. EXPECT_TRUE(waiter1.stream_done());
  2141. EXPECT_TRUE(nullptr == waiter1.websocket_stream());
  2142. ASSERT_TRUE(nullptr != waiter1.stream());
  2143. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2144. EXPECT_EQ(
  2145. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2146. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2147. EXPECT_EQ(
  2148. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2149. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2150. // Verify socket tagged appropriately.
  2151. EXPECT_TRUE(tag1 == socket_factory_ptr->GetLastProducedTCPSocket()->tag());
  2152. EXPECT_TRUE(socket_factory_ptr->GetLastProducedTCPSocket()
  2153. ->tagged_before_connected());
  2154. // Verify one more stream with a different tag results in one more session and
  2155. // socket.
  2156. StreamRequestWaiter waiter2;
  2157. std::unique_ptr<HttpStreamRequest> request2(
  2158. session->http_stream_factory()->RequestStream(
  2159. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2160. /* enable_ip_based_pooling = */ true,
  2161. /* enable_alternative_services = */ true, NetLogWithSource()));
  2162. waiter2.WaitForStream();
  2163. EXPECT_TRUE(waiter2.stream_done());
  2164. EXPECT_TRUE(nullptr == waiter2.websocket_stream());
  2165. ASSERT_TRUE(nullptr != waiter2.stream());
  2166. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2167. EXPECT_EQ(
  2168. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2169. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2170. EXPECT_EQ(
  2171. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2172. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2173. // Verify socket tagged appropriately.
  2174. EXPECT_TRUE(tag2 == socket_factory_ptr->GetLastProducedTCPSocket()->tag());
  2175. EXPECT_TRUE(socket_factory_ptr->GetLastProducedTCPSocket()
  2176. ->tagged_before_connected());
  2177. // Verify one more stream reusing a tag does not create new sessions, groups
  2178. // or sockets.
  2179. StreamRequestWaiter waiter3;
  2180. std::unique_ptr<HttpStreamRequest> request3(
  2181. session->http_stream_factory()->RequestStream(
  2182. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2183. /* enable_ip_based_pooling = */ true,
  2184. /* enable_alternative_services = */ true, NetLogWithSource()));
  2185. waiter3.WaitForStream();
  2186. EXPECT_TRUE(waiter3.stream_done());
  2187. EXPECT_TRUE(nullptr == waiter3.websocket_stream());
  2188. ASSERT_TRUE(nullptr != waiter3.stream());
  2189. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2190. EXPECT_EQ(
  2191. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2192. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2193. EXPECT_EQ(
  2194. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2195. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2196. }
  2197. // Verify HttpStreamFactory::Job passes socket tag along properly to QUIC
  2198. // sessions and that QuicSessions have unique socket tags (e.g. one sessions
  2199. // should not be shared amongst streams with different socket tags).
  2200. TEST_P(HttpStreamFactoryBidirectionalQuicTest, Tag) {
  2201. // Prepare mock QUIC data for a first session establishment.
  2202. MockQuicData mock_quic_data(version());
  2203. spdy::SpdyPriority priority =
  2204. ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
  2205. size_t spdy_headers_frame_length;
  2206. int packet_num = 1;
  2207. if (VersionUsesHttp3(version().transport_version)) {
  2208. mock_quic_data.AddWrite(
  2209. client_packet_maker().MakeInitialSettingsPacket(packet_num++));
  2210. }
  2211. mock_quic_data.AddWrite(client_packet_maker().MakeRequestHeadersPacket(
  2212. packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
  2213. /*should_include_version=*/true,
  2214. /*fin=*/true, priority,
  2215. client_packet_maker().GetRequestHeaders("GET", "https", "/"),
  2216. /*parent_stream_id=*/0, &spdy_headers_frame_length));
  2217. size_t spdy_response_headers_frame_length;
  2218. mock_quic_data.AddRead(server_packet_maker().MakeResponseHeadersPacket(
  2219. 1, GetNthClientInitiatedBidirectionalStreamId(0),
  2220. /*should_include_version=*/false,
  2221. /*fin=*/true, server_packet_maker().GetResponseHeaders("200"),
  2222. &spdy_response_headers_frame_length));
  2223. mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
  2224. mock_quic_data.AddSocketDataToFactory(&socket_factory());
  2225. // Prepare mock QUIC data for a second session establishment.
  2226. client_packet_maker().Reset();
  2227. MockQuicData mock_quic_data2(version());
  2228. packet_num = 1;
  2229. if (VersionUsesHttp3(version().transport_version)) {
  2230. mock_quic_data2.AddWrite(
  2231. client_packet_maker().MakeInitialSettingsPacket(packet_num++));
  2232. }
  2233. mock_quic_data2.AddWrite(client_packet_maker().MakeRequestHeadersPacket(
  2234. packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
  2235. /*should_include_version=*/true,
  2236. /*fin=*/true, priority,
  2237. client_packet_maker().GetRequestHeaders("GET", "https", "/"),
  2238. /*parent_stream_id=*/0, &spdy_headers_frame_length));
  2239. mock_quic_data2.AddRead(server_packet_maker().MakeResponseHeadersPacket(
  2240. 1, GetNthClientInitiatedBidirectionalStreamId(0),
  2241. /*should_include_version=*/false,
  2242. /*fin=*/true, server_packet_maker().GetResponseHeaders("200"),
  2243. &spdy_response_headers_frame_length));
  2244. mock_quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
  2245. mock_quic_data2.AddSocketDataToFactory(&socket_factory());
  2246. // Add hanging data for http job.
  2247. auto hanging_data = std::make_unique<StaticSocketDataProvider>();
  2248. MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
  2249. hanging_data->set_connect_data(hanging_connect);
  2250. socket_factory().AddSocketDataProvider(hanging_data.get());
  2251. SSLSocketDataProvider ssl_data(ASYNC, OK);
  2252. socket_factory().AddSSLSocketDataProvider(&ssl_data);
  2253. // Set up QUIC as alternative_service.
  2254. Initialize();
  2255. AddQuicAlternativeService();
  2256. // Prepare two different tags and corresponding HttpRequestInfos.
  2257. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  2258. HttpRequestInfo request_info1;
  2259. request_info1.method = "GET";
  2260. request_info1.url = default_url_;
  2261. request_info1.load_flags = 0;
  2262. request_info1.socket_tag = tag1;
  2263. request_info1.traffic_annotation =
  2264. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2265. SocketTag tag2(getuid(), 0x87654321);
  2266. HttpRequestInfo request_info2 = request_info1;
  2267. request_info2.socket_tag = tag2;
  2268. request_info2.traffic_annotation =
  2269. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2270. // Verify one stream with one tag results in one QUIC session.
  2271. SSLConfig ssl_config;
  2272. StreamRequestWaiter waiter1;
  2273. std::unique_ptr<HttpStreamRequest> request1(
  2274. session()->http_stream_factory()->RequestStream(
  2275. request_info1, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2276. /* enable_ip_based_pooling = */ true,
  2277. /* enable_alternative_services = */ true, NetLogWithSource()));
  2278. waiter1.WaitForStream();
  2279. EXPECT_TRUE(waiter1.stream_done());
  2280. EXPECT_TRUE(nullptr == waiter1.websocket_stream());
  2281. ASSERT_TRUE(nullptr != waiter1.stream());
  2282. EXPECT_EQ(kProtoQUIC, request1->negotiated_protocol());
  2283. EXPECT_EQ(1, GetQuicSessionCount(session()));
  2284. // Verify socket tagged appropriately.
  2285. EXPECT_TRUE(tag1 == socket_factory().GetLastProducedUDPSocket()->tag());
  2286. EXPECT_TRUE(socket_factory()
  2287. .GetLastProducedUDPSocket()
  2288. ->tagged_before_data_transferred());
  2289. // Verify one more stream with a different tag results in one more session and
  2290. // socket.
  2291. StreamRequestWaiter waiter2;
  2292. std::unique_ptr<HttpStreamRequest> request2(
  2293. session()->http_stream_factory()->RequestStream(
  2294. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2295. /* enable_ip_based_pooling = */ true,
  2296. /* enable_alternative_services = */ true, NetLogWithSource()));
  2297. waiter2.WaitForStream();
  2298. EXPECT_TRUE(waiter2.stream_done());
  2299. EXPECT_TRUE(nullptr == waiter2.websocket_stream());
  2300. ASSERT_TRUE(nullptr != waiter2.stream());
  2301. EXPECT_EQ(kProtoQUIC, request2->negotiated_protocol());
  2302. EXPECT_EQ(2, GetQuicSessionCount(session()));
  2303. // Verify socket tagged appropriately.
  2304. EXPECT_TRUE(tag2 == socket_factory().GetLastProducedUDPSocket()->tag());
  2305. EXPECT_TRUE(socket_factory()
  2306. .GetLastProducedUDPSocket()
  2307. ->tagged_before_data_transferred());
  2308. // Verify one more stream reusing a tag does not create new sessions.
  2309. StreamRequestWaiter waiter3;
  2310. std::unique_ptr<HttpStreamRequest> request3(
  2311. session()->http_stream_factory()->RequestStream(
  2312. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2313. /* enable_ip_based_pooling = */ true,
  2314. /* enable_alternative_services = */ true, NetLogWithSource()));
  2315. waiter3.WaitForStream();
  2316. EXPECT_TRUE(waiter3.stream_done());
  2317. EXPECT_TRUE(nullptr == waiter3.websocket_stream());
  2318. ASSERT_TRUE(nullptr != waiter3.stream());
  2319. EXPECT_EQ(kProtoQUIC, request3->negotiated_protocol());
  2320. EXPECT_EQ(2, GetQuicSessionCount(session()));
  2321. }
  2322. TEST_F(HttpStreamFactoryTest, ChangeSocketTag) {
  2323. SpdySessionDependencies session_deps;
  2324. auto socket_factory = std::make_unique<MockTaggingClientSocketFactory>();
  2325. auto* socket_factory_ptr = socket_factory.get();
  2326. session_deps.socket_factory = std::move(socket_factory);
  2327. // Prepare for two HTTPS connects.
  2328. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  2329. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  2330. base::span<MockWrite>());
  2331. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  2332. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  2333. MockRead mock_read2(SYNCHRONOUS, ERR_IO_PENDING);
  2334. SequencedSocketData socket_data2(base::make_span(&mock_read2, 1),
  2335. base::span<MockWrite>());
  2336. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  2337. session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
  2338. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  2339. // Use cert for *.example.org
  2340. ssl_socket_data.ssl_info.cert =
  2341. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2342. ssl_socket_data.next_proto = kProtoHTTP2;
  2343. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  2344. SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
  2345. // Use cert for *.example.org
  2346. ssl_socket_data2.ssl_info.cert =
  2347. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2348. ssl_socket_data2.next_proto = kProtoHTTP2;
  2349. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data2);
  2350. std::unique_ptr<HttpNetworkSession> session(
  2351. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2352. // Prepare two different tags and corresponding HttpRequestInfos.
  2353. SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
  2354. HttpRequestInfo request_info1;
  2355. request_info1.method = "GET";
  2356. request_info1.url = GURL("https://www.example.org");
  2357. request_info1.load_flags = 0;
  2358. request_info1.socket_tag = tag1;
  2359. request_info1.traffic_annotation =
  2360. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2361. SocketTag tag2(getuid(), 0x87654321);
  2362. HttpRequestInfo request_info2 = request_info1;
  2363. request_info2.socket_tag = tag2;
  2364. request_info2.traffic_annotation =
  2365. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2366. // Prepare another HttpRequestInfo with tag1 and a different host name.
  2367. HttpRequestInfo request_info3 = request_info1;
  2368. request_info3.url = GURL("https://foo.example.org");
  2369. request_info3.traffic_annotation =
  2370. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2371. // Verify one stream with one tag results in one session, group and
  2372. // socket.
  2373. SSLConfig ssl_config;
  2374. StreamRequestWaiter waiter1;
  2375. std::unique_ptr<HttpStreamRequest> request1(
  2376. session->http_stream_factory()->RequestStream(
  2377. request_info1, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2378. /* enable_ip_based_pooling = */ true,
  2379. /* enable_alternative_services = */ true, NetLogWithSource()));
  2380. waiter1.WaitForStream();
  2381. EXPECT_TRUE(waiter1.stream_done());
  2382. EXPECT_FALSE(waiter1.websocket_stream());
  2383. ASSERT_TRUE(waiter1.stream());
  2384. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2385. EXPECT_EQ(
  2386. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2387. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2388. EXPECT_EQ(
  2389. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2390. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2391. // Verify socket tagged appropriately.
  2392. MockTaggingStreamSocket* socket =
  2393. socket_factory_ptr->GetLastProducedTCPSocket();
  2394. EXPECT_TRUE(tag1 == socket->tag());
  2395. EXPECT_TRUE(socket->tagged_before_connected());
  2396. // Verify the socket tag on the first session can be changed.
  2397. StreamRequestWaiter waiter2;
  2398. std::unique_ptr<HttpStreamRequest> request2(
  2399. session->http_stream_factory()->RequestStream(
  2400. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2401. /* enable_ip_based_pooling = */ true,
  2402. /* enable_alternative_services = */ true, NetLogWithSource()));
  2403. waiter2.WaitForStream();
  2404. EXPECT_TRUE(waiter2.stream_done());
  2405. EXPECT_FALSE(waiter2.websocket_stream());
  2406. ASSERT_TRUE(waiter2.stream());
  2407. // Verify still have just one session.
  2408. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2409. EXPECT_EQ(
  2410. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2411. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2412. EXPECT_EQ(
  2413. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2414. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2415. // Verify no new sockets created.
  2416. EXPECT_EQ(socket, socket_factory_ptr->GetLastProducedTCPSocket());
  2417. // Verify socket tag changed.
  2418. EXPECT_TRUE(tag2 == socket->tag());
  2419. EXPECT_FALSE(socket->tagged_before_connected());
  2420. // Verify attempting to use the first stream fails because the session's
  2421. // socket tag has since changed.
  2422. TestCompletionCallback callback1;
  2423. waiter1.stream()->RegisterRequest(&request_info1);
  2424. EXPECT_EQ(ERR_FAILED, waiter1.stream()->InitializeStream(
  2425. /* can_send_early = */ false, DEFAULT_PRIORITY,
  2426. NetLogWithSource(), callback1.callback()));
  2427. // Verify the socket tag can be changed, this time using an IP alias
  2428. // (different host, same IP).
  2429. StreamRequestWaiter waiter3;
  2430. std::unique_ptr<HttpStreamRequest> request3(
  2431. session->http_stream_factory()->RequestStream(
  2432. request_info3, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2433. /* enable_ip_based_pooling = */ true,
  2434. /* enable_alternative_services = */ true, NetLogWithSource()));
  2435. waiter3.WaitForStream();
  2436. EXPECT_TRUE(waiter3.stream_done());
  2437. EXPECT_FALSE(waiter3.websocket_stream());
  2438. ASSERT_TRUE(waiter3.stream());
  2439. // Verify still have just one session.
  2440. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2441. EXPECT_EQ(
  2442. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2443. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2444. EXPECT_EQ(
  2445. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2446. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2447. // Verify no new sockets created.
  2448. EXPECT_EQ(socket, socket_factory_ptr->GetLastProducedTCPSocket());
  2449. // Verify socket tag changed.
  2450. EXPECT_TRUE(tag1 == socket->tag());
  2451. EXPECT_FALSE(socket->tagged_before_connected());
  2452. // Initialize the third stream, thus marking the session active, so it cannot
  2453. // have its socket tag changed.
  2454. TestCompletionCallback callback3;
  2455. waiter3.stream()->RegisterRequest(&request_info3);
  2456. EXPECT_EQ(OK, waiter3.stream()->InitializeStream(
  2457. /* can_send_early = */ false, DEFAULT_PRIORITY,
  2458. NetLogWithSource(), callback3.callback()));
  2459. // Verify a new session is created when a request with a different tag is
  2460. // started.
  2461. StreamRequestWaiter waiter4;
  2462. std::unique_ptr<HttpStreamRequest> request4(
  2463. session->http_stream_factory()->RequestStream(
  2464. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter4,
  2465. /* enable_ip_based_pooling = */ true,
  2466. /* enable_alternative_services = */ true, NetLogWithSource()));
  2467. waiter4.WaitForStream();
  2468. EXPECT_TRUE(waiter4.stream_done());
  2469. EXPECT_FALSE(waiter4.websocket_stream());
  2470. ASSERT_TRUE(waiter4.stream());
  2471. // Verify we now have two sessions.
  2472. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2473. EXPECT_EQ(
  2474. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2475. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2476. EXPECT_EQ(
  2477. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2478. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2479. // Verify a new socket was created.
  2480. MockTaggingStreamSocket* socket2 =
  2481. socket_factory_ptr->GetLastProducedTCPSocket();
  2482. EXPECT_NE(socket, socket2);
  2483. // Verify tag set appropriately.
  2484. EXPECT_TRUE(tag2 == socket2->tag());
  2485. EXPECT_TRUE(socket2->tagged_before_connected());
  2486. // Verify tag on original socket is unchanged.
  2487. EXPECT_TRUE(tag1 == socket->tag());
  2488. waiter3.stream()->Close(/* not_reusable = */ true);
  2489. }
  2490. // Regression test for https://crbug.com/954503.
  2491. TEST_F(HttpStreamFactoryTest, ChangeSocketTagAvoidOverwrite) {
  2492. SpdySessionDependencies session_deps;
  2493. auto socket_factory = std::make_unique<MockTaggingClientSocketFactory>();
  2494. auto* socket_factory_ptr = socket_factory.get();
  2495. session_deps.socket_factory = std::move(socket_factory);
  2496. // Prepare for two HTTPS connects.
  2497. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  2498. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  2499. base::span<MockWrite>());
  2500. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  2501. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  2502. MockRead mock_read2(SYNCHRONOUS, ERR_IO_PENDING);
  2503. SequencedSocketData socket_data2(base::make_span(&mock_read2, 1),
  2504. base::span<MockWrite>());
  2505. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  2506. session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
  2507. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  2508. // Use cert for *.example.org
  2509. ssl_socket_data.ssl_info.cert =
  2510. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2511. ssl_socket_data.next_proto = kProtoHTTP2;
  2512. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  2513. SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
  2514. // Use cert for *.example.org
  2515. ssl_socket_data2.ssl_info.cert =
  2516. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2517. ssl_socket_data2.next_proto = kProtoHTTP2;
  2518. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data2);
  2519. std::unique_ptr<HttpNetworkSession> session(
  2520. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2521. // Prepare three different tags and corresponding HttpRequestInfos.
  2522. SocketTag tag1(SocketTag::UNSET_UID, 2);
  2523. HttpRequestInfo request_info1;
  2524. request_info1.method = "GET";
  2525. request_info1.url = GURL("https://www.example.org");
  2526. request_info1.load_flags = 0;
  2527. request_info1.socket_tag = tag1;
  2528. request_info1.traffic_annotation =
  2529. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2530. SocketTag tag2(SocketTag::UNSET_UID, 1);
  2531. HttpRequestInfo request_info2 = request_info1;
  2532. request_info2.socket_tag = tag2;
  2533. HttpRequestInfo request_info3 = request_info1;
  2534. SocketTag tag3(SocketTag::UNSET_UID, 3);
  2535. request_info3.socket_tag = tag3;
  2536. // Prepare another HttpRequestInfo with tag3 and a different host name.
  2537. HttpRequestInfo request_info4 = request_info1;
  2538. request_info4.socket_tag = tag3;
  2539. request_info4.url = GURL("https://foo.example.org");
  2540. // Verify one stream with one tag results in one session, group and
  2541. // socket.
  2542. SSLConfig ssl_config;
  2543. StreamRequestWaiter waiter1;
  2544. std::unique_ptr<HttpStreamRequest> request1(
  2545. session->http_stream_factory()->RequestStream(
  2546. request_info1, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2547. /* enable_ip_based_pooling = */ true,
  2548. /* enable_alternative_services = */ true, NetLogWithSource()));
  2549. waiter1.WaitForStream();
  2550. EXPECT_TRUE(waiter1.stream_done());
  2551. EXPECT_FALSE(waiter1.websocket_stream());
  2552. ASSERT_TRUE(waiter1.stream());
  2553. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2554. EXPECT_EQ(
  2555. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2556. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2557. EXPECT_EQ(
  2558. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2559. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2560. // Verify socket tagged appropriately.
  2561. MockTaggingStreamSocket* socket =
  2562. socket_factory_ptr->GetLastProducedTCPSocket();
  2563. EXPECT_TRUE(tag1 == socket->tag());
  2564. EXPECT_TRUE(socket->tagged_before_connected());
  2565. // Initialize the first stream, thus marking the session active, so it cannot
  2566. // have its socket tag changed and be reused for the second session.
  2567. TestCompletionCallback callback1;
  2568. waiter1.stream()->RegisterRequest(&request_info1);
  2569. EXPECT_EQ(OK, waiter1.stream()->InitializeStream(
  2570. /* can_send_early = */ false, DEFAULT_PRIORITY,
  2571. NetLogWithSource(), callback1.callback()));
  2572. // Create a second stream with a new tag.
  2573. StreamRequestWaiter waiter2;
  2574. std::unique_ptr<HttpStreamRequest> request2(
  2575. session->http_stream_factory()->RequestStream(
  2576. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2577. /* enable_ip_based_pooling = */ true,
  2578. /* enable_alternative_services = */ true, NetLogWithSource()));
  2579. waiter2.WaitForStream();
  2580. EXPECT_TRUE(waiter2.stream_done());
  2581. EXPECT_FALSE(waiter2.websocket_stream());
  2582. ASSERT_TRUE(waiter2.stream());
  2583. // Verify we now have two sessions.
  2584. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2585. EXPECT_EQ(
  2586. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2587. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2588. EXPECT_EQ(
  2589. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2590. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2591. // Verify a new socket was created.
  2592. MockTaggingStreamSocket* socket2 =
  2593. socket_factory_ptr->GetLastProducedTCPSocket();
  2594. EXPECT_NE(socket, socket2);
  2595. // Verify tag set appropriately.
  2596. EXPECT_TRUE(tag2 == socket2->tag());
  2597. EXPECT_TRUE(socket2->tagged_before_connected());
  2598. // Verify tag on original socket is unchanged.
  2599. EXPECT_TRUE(tag1 == socket->tag());
  2600. // Initialize the second stream, thus marking the session active, so it cannot
  2601. // have its socket tag changed and be reused for the third session.
  2602. TestCompletionCallback callback2;
  2603. waiter2.stream()->RegisterRequest(&request_info2);
  2604. EXPECT_EQ(OK, waiter2.stream()->InitializeStream(
  2605. /* can_send_early = */ false, DEFAULT_PRIORITY,
  2606. NetLogWithSource(), callback2.callback()));
  2607. // Release first stream so first session can be retagged for third request.
  2608. waiter1.stream()->Close(/* not_reusable = */ true);
  2609. // Verify the first session can be retagged for a third request.
  2610. StreamRequestWaiter waiter3;
  2611. std::unique_ptr<HttpStreamRequest> request3(
  2612. session->http_stream_factory()->RequestStream(
  2613. request_info3, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2614. /* enable_ip_based_pooling = */ true,
  2615. /* enable_alternative_services = */ true, NetLogWithSource()));
  2616. waiter3.WaitForStream();
  2617. EXPECT_TRUE(waiter3.stream_done());
  2618. EXPECT_FALSE(waiter3.websocket_stream());
  2619. ASSERT_TRUE(waiter3.stream());
  2620. // Verify still have two sessions.
  2621. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2622. EXPECT_EQ(
  2623. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2624. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2625. EXPECT_EQ(
  2626. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2627. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2628. // Verify no new sockets created.
  2629. EXPECT_EQ(socket2, socket_factory_ptr->GetLastProducedTCPSocket());
  2630. // Verify socket tag changed.
  2631. EXPECT_TRUE(tag3 == socket->tag());
  2632. EXPECT_FALSE(socket->tagged_before_connected());
  2633. // Release second stream so second session can be retagged for fourth request.
  2634. waiter2.stream()->Close(/* not_reusable = */ true);
  2635. // Request a stream with a new tag and a different host that aliases existing
  2636. // sessions.
  2637. StreamRequestWaiter waiter4;
  2638. std::unique_ptr<HttpStreamRequest> request4(
  2639. session->http_stream_factory()->RequestStream(
  2640. request_info4, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter4,
  2641. /* enable_ip_based_pooling = */ true,
  2642. /* enable_alternative_services = */ true, NetLogWithSource()));
  2643. waiter4.WaitForStream();
  2644. EXPECT_TRUE(waiter4.stream_done());
  2645. EXPECT_FALSE(waiter4.websocket_stream());
  2646. ASSERT_TRUE(waiter4.stream());
  2647. // Verify no new sockets created.
  2648. EXPECT_EQ(socket2, socket_factory_ptr->GetLastProducedTCPSocket());
  2649. }
  2650. #endif
  2651. // Test that when creating a stream all sessions that alias an IP are tried,
  2652. // not just one. This is important because there can be multiple sessions
  2653. // that could satisfy a stream request and they should all be tried.
  2654. TEST_F(HttpStreamFactoryTest, MultiIPAliases) {
  2655. SpdySessionDependencies session_deps;
  2656. // Prepare for two HTTPS connects.
  2657. MockRead mock_read1(SYNCHRONOUS, ERR_IO_PENDING);
  2658. SequencedSocketData socket_data1(base::make_span(&mock_read1, 1),
  2659. base::span<MockWrite>());
  2660. socket_data1.set_connect_data(MockConnect(ASYNC, OK));
  2661. session_deps.socket_factory->AddSocketDataProvider(&socket_data1);
  2662. MockRead mock_read2(SYNCHRONOUS, ERR_IO_PENDING);
  2663. SequencedSocketData socket_data2(base::make_span(&mock_read2, 1),
  2664. base::span<MockWrite>());
  2665. socket_data2.set_connect_data(MockConnect(ASYNC, OK));
  2666. session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
  2667. SSLSocketDataProvider ssl_socket_data1(ASYNC, OK);
  2668. // Load cert for *.example.org
  2669. ssl_socket_data1.ssl_info.cert =
  2670. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2671. ssl_socket_data1.next_proto = kProtoHTTP2;
  2672. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data1);
  2673. SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
  2674. // Load cert for *.example.org
  2675. ssl_socket_data2.ssl_info.cert =
  2676. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2677. ssl_socket_data2.next_proto = kProtoHTTP2;
  2678. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data2);
  2679. std::unique_ptr<HttpNetworkSession> session(
  2680. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2681. // Create two HttpRequestInfos, differing only in host name.
  2682. // Both will resolve to 127.0.0.1 and hence be IP aliases.
  2683. HttpRequestInfo request_info1;
  2684. request_info1.method = "GET";
  2685. request_info1.url = GURL("https://a.example.org");
  2686. request_info1.privacy_mode = PRIVACY_MODE_DISABLED;
  2687. request_info1.traffic_annotation =
  2688. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2689. HttpRequestInfo request_info1_alias = request_info1;
  2690. request_info1.url = GURL("https://b.example.org");
  2691. // Create two more HttpRequestInfos but with different privacy_mode.
  2692. HttpRequestInfo request_info2;
  2693. request_info2.method = "GET";
  2694. request_info2.url = GURL("https://a.example.org");
  2695. request_info2.privacy_mode = PRIVACY_MODE_ENABLED;
  2696. request_info2.traffic_annotation =
  2697. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2698. HttpRequestInfo request_info2_alias = request_info2;
  2699. request_info2.url = GURL("https://b.example.org");
  2700. // Open one session.
  2701. SSLConfig ssl_config;
  2702. StreamRequestWaiter waiter1;
  2703. std::unique_ptr<HttpStreamRequest> request1(
  2704. session->http_stream_factory()->RequestStream(
  2705. request_info1, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2706. /* enable_ip_based_pooling = */ true,
  2707. /* enable_alternative_services = */ true, NetLogWithSource()));
  2708. waiter1.WaitForStream();
  2709. EXPECT_TRUE(waiter1.stream_done());
  2710. EXPECT_FALSE(waiter1.websocket_stream());
  2711. ASSERT_TRUE(waiter1.stream());
  2712. // Verify just one session created.
  2713. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2714. EXPECT_EQ(
  2715. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2716. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2717. EXPECT_EQ(
  2718. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2719. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2720. // Open another session to same IP but with different privacy mode.
  2721. StreamRequestWaiter waiter2;
  2722. std::unique_ptr<HttpStreamRequest> request2(
  2723. session->http_stream_factory()->RequestStream(
  2724. request_info2, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2725. /* enable_ip_based_pooling = */ true,
  2726. /* enable_alternative_services = */ true, NetLogWithSource()));
  2727. waiter2.WaitForStream();
  2728. EXPECT_TRUE(waiter2.stream_done());
  2729. EXPECT_FALSE(waiter2.websocket_stream());
  2730. ASSERT_TRUE(waiter2.stream());
  2731. // Verify two sessions are now open.
  2732. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2733. EXPECT_EQ(
  2734. 2, GetSocketPoolGroupCount(session->GetSocketPool(
  2735. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2736. EXPECT_EQ(
  2737. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2738. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2739. // Open a third session that IP aliases first session.
  2740. StreamRequestWaiter waiter3;
  2741. std::unique_ptr<HttpStreamRequest> request3(
  2742. session->http_stream_factory()->RequestStream(
  2743. request_info1_alias, DEFAULT_PRIORITY, ssl_config, ssl_config,
  2744. &waiter3,
  2745. /* enable_ip_based_pooling = */ true,
  2746. /* enable_alternative_services = */ true, NetLogWithSource()));
  2747. waiter3.WaitForStream();
  2748. EXPECT_TRUE(waiter3.stream_done());
  2749. EXPECT_FALSE(waiter3.websocket_stream());
  2750. ASSERT_TRUE(waiter3.stream());
  2751. // Verify the session pool reused the first session and no new session is
  2752. // created. This will fail unless the session pool supports multiple
  2753. // sessions aliasing a single IP.
  2754. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2755. EXPECT_EQ(
  2756. 2, GetSocketPoolGroupCount(session->GetSocketPool(
  2757. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2758. EXPECT_EQ(
  2759. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2760. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2761. // Open a fourth session that IP aliases the second session.
  2762. StreamRequestWaiter waiter4;
  2763. std::unique_ptr<HttpStreamRequest> request4(
  2764. session->http_stream_factory()->RequestStream(
  2765. request_info2_alias, DEFAULT_PRIORITY, ssl_config, ssl_config,
  2766. &waiter4,
  2767. /* enable_ip_based_pooling = */ true,
  2768. /* enable_alternative_services = */ true, NetLogWithSource()));
  2769. waiter4.WaitForStream();
  2770. EXPECT_TRUE(waiter4.stream_done());
  2771. EXPECT_FALSE(waiter4.websocket_stream());
  2772. ASSERT_TRUE(waiter4.stream());
  2773. // Verify the session pool reused the second session. This will fail unless
  2774. // the session pool supports multiple sessions aliasing a single IP.
  2775. EXPECT_EQ(2, GetSpdySessionCount(session.get()));
  2776. EXPECT_EQ(
  2777. 2, GetSocketPoolGroupCount(session->GetSocketPool(
  2778. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2779. EXPECT_EQ(
  2780. 2, GetHandedOutSocketCount(session->GetSocketPool(
  2781. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2782. }
  2783. TEST_F(HttpStreamFactoryTest, SpdyIPPoolingWithDnsAliases) {
  2784. SpdySessionDependencies session_deps;
  2785. const std::set<std::string> kDnsAliasesA({"alias1", "alias2"});
  2786. const std::set<std::string> kDnsAliasesB({"b.com", "b.org", "b.net"});
  2787. const std::string kHostnameC("c.example.org");
  2788. session_deps.host_resolver->rules()->AddIPLiteralRuleWithDnsAliases(
  2789. "a.example.org", "127.0.0.1", kDnsAliasesA);
  2790. session_deps.host_resolver->rules()->AddIPLiteralRuleWithDnsAliases(
  2791. "b.example.org", "127.0.0.1", kDnsAliasesB);
  2792. session_deps.host_resolver->rules()->AddIPLiteralRuleWithDnsAliases(
  2793. "c.example.org", "127.0.0.1", /*dns_aliases=*/std::set<std::string>());
  2794. // Prepare for an HTTPS connect.
  2795. MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
  2796. SequencedSocketData socket_data(base::make_span(&mock_read, 1),
  2797. base::span<MockWrite>());
  2798. socket_data.set_connect_data(MockConnect(ASYNC, OK));
  2799. session_deps.socket_factory->AddSocketDataProvider(&socket_data);
  2800. SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
  2801. // Load cert for *.example.org
  2802. ssl_socket_data.ssl_info.cert =
  2803. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
  2804. ssl_socket_data.next_proto = kProtoHTTP2;
  2805. session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
  2806. std::unique_ptr<HttpNetworkSession> session(
  2807. SpdySessionDependencies::SpdyCreateSession(&session_deps));
  2808. // Create three HttpRequestInfos, differing only in host name.
  2809. // All three will resolve to 127.0.0.1 and hence be IP aliases.
  2810. HttpRequestInfo request_info_a;
  2811. request_info_a.method = "GET";
  2812. request_info_a.url = GURL("https://a.example.org");
  2813. request_info_a.privacy_mode = PRIVACY_MODE_DISABLED;
  2814. request_info_a.traffic_annotation =
  2815. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  2816. HttpRequestInfo request_info_b = request_info_a;
  2817. HttpRequestInfo request_info_c = request_info_a;
  2818. request_info_b.url = GURL("https://b.example.org");
  2819. request_info_c.url = GURL("https://c.example.org");
  2820. // Open one session.
  2821. SSLConfig ssl_config;
  2822. StreamRequestWaiter waiter1;
  2823. std::unique_ptr<HttpStreamRequest> request1(
  2824. session->http_stream_factory()->RequestStream(
  2825. request_info_a, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2826. /* enable_ip_based_pooling = */ true,
  2827. /* enable_alternative_services = */ true, NetLogWithSource()));
  2828. waiter1.WaitForStream();
  2829. EXPECT_TRUE(waiter1.stream_done());
  2830. EXPECT_FALSE(waiter1.websocket_stream());
  2831. ASSERT_TRUE(waiter1.stream());
  2832. EXPECT_EQ(kDnsAliasesA, waiter1.stream()->GetDnsAliases());
  2833. // Verify just one session created.
  2834. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2835. EXPECT_EQ(
  2836. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2837. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2838. EXPECT_EQ(
  2839. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2840. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2841. // Open a session that IP aliases first session.
  2842. StreamRequestWaiter waiter2;
  2843. std::unique_ptr<HttpStreamRequest> request2(
  2844. session->http_stream_factory()->RequestStream(
  2845. request_info_b, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2846. /* enable_ip_based_pooling = */ true,
  2847. /* enable_alternative_services = */ true, NetLogWithSource()));
  2848. waiter2.WaitForStream();
  2849. EXPECT_TRUE(waiter2.stream_done());
  2850. EXPECT_FALSE(waiter2.websocket_stream());
  2851. ASSERT_TRUE(waiter2.stream());
  2852. EXPECT_EQ(kDnsAliasesB, waiter2.stream()->GetDnsAliases());
  2853. // Verify the session pool reused the first session and no new session is
  2854. // created. This will fail unless the session pool supports multiple
  2855. // sessions aliasing a single IP.
  2856. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2857. EXPECT_EQ(
  2858. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2859. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2860. EXPECT_EQ(
  2861. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2862. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2863. // Open another session that IP aliases the first session.
  2864. StreamRequestWaiter waiter3;
  2865. std::unique_ptr<HttpStreamRequest> request3(
  2866. session->http_stream_factory()->RequestStream(
  2867. request_info_c, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2868. /* enable_ip_based_pooling = */ true,
  2869. /* enable_alternative_services = */ true, NetLogWithSource()));
  2870. waiter3.WaitForStream();
  2871. EXPECT_TRUE(waiter3.stream_done());
  2872. EXPECT_FALSE(waiter3.websocket_stream());
  2873. ASSERT_TRUE(waiter3.stream());
  2874. EXPECT_THAT(waiter3.stream()->GetDnsAliases(), ElementsAre(kHostnameC));
  2875. // Verify the session pool reused the first session and no new session is
  2876. // created. This will fail unless the session pool supports multiple
  2877. // sessions aliasing a single IP.
  2878. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2879. EXPECT_EQ(
  2880. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2881. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2882. EXPECT_EQ(
  2883. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2884. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2885. // Clear host resolver rules to ensure that cached values for DNS aliases
  2886. // are used.
  2887. session_deps.host_resolver->rules()->ClearRules();
  2888. // Re-request the original resource using `request_info_a`, which had
  2889. // non-default DNS aliases.
  2890. std::unique_ptr<HttpStreamRequest> request4(
  2891. session->http_stream_factory()->RequestStream(
  2892. request_info_a, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  2893. /* enable_ip_based_pooling = */ true,
  2894. /* enable_alternative_services = */ true, NetLogWithSource()));
  2895. waiter1.WaitForStream();
  2896. EXPECT_TRUE(waiter1.stream_done());
  2897. EXPECT_FALSE(waiter1.websocket_stream());
  2898. ASSERT_TRUE(waiter1.stream());
  2899. EXPECT_EQ(kDnsAliasesA, waiter1.stream()->GetDnsAliases());
  2900. // Verify the session pool reused the first session and no new session is
  2901. // created.
  2902. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2903. EXPECT_EQ(
  2904. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2905. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2906. EXPECT_EQ(
  2907. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2908. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2909. // Re-request a resource using `request_info_b`, which had non-default DNS
  2910. // aliases.
  2911. std::unique_ptr<HttpStreamRequest> request5(
  2912. session->http_stream_factory()->RequestStream(
  2913. request_info_b, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  2914. /* enable_ip_based_pooling = */ true,
  2915. /* enable_alternative_services = */ true, NetLogWithSource()));
  2916. waiter2.WaitForStream();
  2917. EXPECT_TRUE(waiter2.stream_done());
  2918. EXPECT_FALSE(waiter2.websocket_stream());
  2919. ASSERT_TRUE(waiter2.stream());
  2920. EXPECT_EQ(kDnsAliasesB, waiter2.stream()->GetDnsAliases());
  2921. // Verify the session pool reused the first session and no new session is
  2922. // created. This will fail unless the session pool supports multiple
  2923. // sessions aliasing a single IP.
  2924. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2925. EXPECT_EQ(
  2926. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2927. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2928. EXPECT_EQ(
  2929. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2930. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2931. // Re-request a resource using `request_info_c`, which had only the default
  2932. // DNS alias (the host name).
  2933. std::unique_ptr<HttpStreamRequest> request6(
  2934. session->http_stream_factory()->RequestStream(
  2935. request_info_c, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  2936. /* enable_ip_based_pooling = */ true,
  2937. /* enable_alternative_services = */ true, NetLogWithSource()));
  2938. waiter3.WaitForStream();
  2939. EXPECT_TRUE(waiter3.stream_done());
  2940. EXPECT_FALSE(waiter3.websocket_stream());
  2941. ASSERT_TRUE(waiter3.stream());
  2942. EXPECT_THAT(waiter3.stream()->GetDnsAliases(), ElementsAre(kHostnameC));
  2943. // Verify the session pool reused the first session and no new session is
  2944. // created. This will fail unless the session pool supports multiple
  2945. // sessions aliasing a single IP.
  2946. EXPECT_EQ(1, GetSpdySessionCount(session.get()));
  2947. EXPECT_EQ(
  2948. 1, GetSocketPoolGroupCount(session->GetSocketPool(
  2949. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2950. EXPECT_EQ(
  2951. 1, GetHandedOutSocketCount(session->GetSocketPool(
  2952. HttpNetworkSession::NORMAL_SOCKET_POOL, ProxyServer::Direct())));
  2953. }
  2954. TEST_P(HttpStreamFactoryBidirectionalQuicTest, QuicIPPoolingWithDnsAliases) {
  2955. const GURL kUrlA("https://a.example.org");
  2956. const GURL kUrlB("https://b.example.org");
  2957. const GURL kUrlC("https://c.example.org");
  2958. const std::set<std::string> kDnsAliasesA({"alias1", "alias2"});
  2959. const std::set<std::string> kDnsAliasesB({"b.com", "b.org", "b.net"});
  2960. host_resolver()->rules()->AddIPLiteralRuleWithDnsAliases(
  2961. kUrlA.host(), "127.0.0.1", kDnsAliasesA);
  2962. host_resolver()->rules()->AddIPLiteralRuleWithDnsAliases(
  2963. kUrlB.host(), "127.0.0.1", kDnsAliasesB);
  2964. host_resolver()->rules()->AddIPLiteralRuleWithDnsAliases(
  2965. kUrlC.host(), "127.0.0.1",
  2966. /*dns_aliases=*/std::set<std::string>());
  2967. // Prepare mock QUIC data for a first session establishment.
  2968. MockQuicData mock_quic_data(version());
  2969. spdy::SpdyPriority priority =
  2970. ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
  2971. size_t spdy_headers_frame_length;
  2972. int packet_num = 1;
  2973. if (VersionUsesHttp3(version().transport_version)) {
  2974. mock_quic_data.AddWrite(
  2975. client_packet_maker().MakeInitialSettingsPacket(packet_num++));
  2976. }
  2977. mock_quic_data.AddWrite(client_packet_maker().MakeRequestHeadersPacket(
  2978. packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
  2979. /*should_include_version=*/true,
  2980. /*fin=*/true, priority,
  2981. client_packet_maker().GetRequestHeaders("GET", "https", "/"),
  2982. /*parent_stream_id=*/0, &spdy_headers_frame_length));
  2983. size_t spdy_response_headers_frame_length;
  2984. mock_quic_data.AddRead(server_packet_maker().MakeResponseHeadersPacket(
  2985. 1, GetNthClientInitiatedBidirectionalStreamId(0),
  2986. /*should_include_version=*/false,
  2987. /*fin=*/true, server_packet_maker().GetResponseHeaders("200"),
  2988. &spdy_response_headers_frame_length));
  2989. mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
  2990. mock_quic_data.AddSocketDataToFactory(&socket_factory());
  2991. // Add hanging data for http job.
  2992. auto hanging_data = std::make_unique<StaticSocketDataProvider>();
  2993. MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
  2994. hanging_data->set_connect_data(hanging_connect);
  2995. socket_factory().AddSocketDataProvider(hanging_data.get());
  2996. SSLSocketDataProvider ssl_data(ASYNC, OK);
  2997. socket_factory().AddSSLSocketDataProvider(&ssl_data);
  2998. // Set up QUIC as alternative_service.
  2999. Initialize();
  3000. AddQuicAlternativeService(url::SchemeHostPort(kUrlA), kUrlA.host());
  3001. AddQuicAlternativeService(url::SchemeHostPort(kUrlB), kUrlB.host());
  3002. AddQuicAlternativeService(url::SchemeHostPort(kUrlC), kUrlC.host());
  3003. // Create three HttpRequestInfos, differing only in host name.
  3004. // All three will resolve to 127.0.0.1 and hence be IP aliases.
  3005. HttpRequestInfo request_info_a;
  3006. request_info_a.method = "GET";
  3007. request_info_a.url = kUrlA;
  3008. request_info_a.privacy_mode = PRIVACY_MODE_DISABLED;
  3009. request_info_a.traffic_annotation =
  3010. MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  3011. HttpRequestInfo request_info_b = request_info_a;
  3012. HttpRequestInfo request_info_c = request_info_a;
  3013. request_info_b.url = kUrlB;
  3014. request_info_c.url = kUrlC;
  3015. // Open one session.
  3016. SSLConfig ssl_config;
  3017. StreamRequestWaiter waiter1;
  3018. std::unique_ptr<HttpStreamRequest> request1(
  3019. session()->http_stream_factory()->RequestStream(
  3020. request_info_a, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  3021. /* enable_ip_based_pooling = */ true,
  3022. /* enable_alternative_services = */ true, NetLogWithSource()));
  3023. waiter1.WaitForStream();
  3024. EXPECT_TRUE(waiter1.stream_done());
  3025. EXPECT_FALSE(waiter1.websocket_stream());
  3026. ASSERT_TRUE(waiter1.stream());
  3027. EXPECT_EQ(kDnsAliasesA, waiter1.stream()->GetDnsAliases());
  3028. // Verify just one session created.
  3029. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3030. EXPECT_EQ(kProtoQUIC, request1->negotiated_protocol());
  3031. // Create a request that will alias and reuse the first session.
  3032. StreamRequestWaiter waiter2;
  3033. std::unique_ptr<HttpStreamRequest> request2(
  3034. session()->http_stream_factory()->RequestStream(
  3035. request_info_b, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  3036. /* enable_ip_based_pooling = */ true,
  3037. /* enable_alternative_services = */ true, NetLogWithSource()));
  3038. waiter2.WaitForStream();
  3039. EXPECT_TRUE(waiter2.stream_done());
  3040. EXPECT_FALSE(waiter2.websocket_stream());
  3041. ASSERT_TRUE(waiter2.stream());
  3042. EXPECT_EQ(kDnsAliasesB, waiter2.stream()->GetDnsAliases());
  3043. // Verify the session pool reused the first session and no new session is
  3044. // created. This will fail unless the session pool supports multiple
  3045. // sessions aliasing a single IP.
  3046. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3047. EXPECT_EQ(kProtoQUIC, request2->negotiated_protocol());
  3048. // Create another request that will alias and reuse the first session.
  3049. StreamRequestWaiter waiter3;
  3050. std::unique_ptr<HttpStreamRequest> request3(
  3051. session()->http_stream_factory()->RequestStream(
  3052. request_info_c, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  3053. /* enable_ip_based_pooling = */ true,
  3054. /* enable_alternative_services = */ true, NetLogWithSource()));
  3055. waiter3.WaitForStream();
  3056. EXPECT_TRUE(waiter3.stream_done());
  3057. EXPECT_FALSE(waiter3.websocket_stream());
  3058. ASSERT_TRUE(waiter3.stream());
  3059. EXPECT_THAT(waiter3.stream()->GetDnsAliases(), ElementsAre(kUrlC.host()));
  3060. // Clear the host resolve rules to ensure that we are using cached info.
  3061. host_resolver()->rules()->ClearRules();
  3062. // Verify the session pool reused the first session and no new session is
  3063. // created. This will fail unless the session pool supports multiple
  3064. // sessions aliasing a single IP.
  3065. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3066. EXPECT_EQ(kProtoQUIC, request3->negotiated_protocol());
  3067. // Create a request that will reuse the first session.
  3068. std::unique_ptr<HttpStreamRequest> request4(
  3069. session()->http_stream_factory()->RequestStream(
  3070. request_info_a, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1,
  3071. /* enable_ip_based_pooling = */ true,
  3072. /* enable_alternative_services = */ true, NetLogWithSource()));
  3073. waiter1.WaitForStream();
  3074. EXPECT_TRUE(waiter1.stream_done());
  3075. EXPECT_FALSE(waiter1.websocket_stream());
  3076. ASSERT_TRUE(waiter1.stream());
  3077. EXPECT_EQ(kDnsAliasesA, waiter1.stream()->GetDnsAliases());
  3078. // Verify the session pool reused the first session and no new session is
  3079. // created.
  3080. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3081. EXPECT_EQ(kProtoQUIC, request4->negotiated_protocol());
  3082. // Create another request that will alias and reuse the first session.
  3083. std::unique_ptr<HttpStreamRequest> request5(
  3084. session()->http_stream_factory()->RequestStream(
  3085. request_info_b, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2,
  3086. /* enable_ip_based_pooling = */ true,
  3087. /* enable_alternative_services = */ true, NetLogWithSource()));
  3088. waiter2.WaitForStream();
  3089. EXPECT_TRUE(waiter2.stream_done());
  3090. EXPECT_FALSE(waiter2.websocket_stream());
  3091. ASSERT_TRUE(waiter2.stream());
  3092. EXPECT_EQ(kDnsAliasesB, waiter2.stream()->GetDnsAliases());
  3093. // Verify the session pool reused the first session and no new session is
  3094. // created. This will fail unless the session pool supports multiple
  3095. // sessions aliasing a single IP.
  3096. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3097. EXPECT_EQ(kProtoQUIC, request5->negotiated_protocol());
  3098. // Create another request that will alias and reuse the first session.
  3099. std::unique_ptr<HttpStreamRequest> request6(
  3100. session()->http_stream_factory()->RequestStream(
  3101. request_info_c, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter3,
  3102. /* enable_ip_based_pooling = */ true,
  3103. /* enable_alternative_services = */ true, NetLogWithSource()));
  3104. waiter3.WaitForStream();
  3105. EXPECT_TRUE(waiter3.stream_done());
  3106. EXPECT_FALSE(waiter3.websocket_stream());
  3107. ASSERT_TRUE(waiter3.stream());
  3108. EXPECT_THAT(waiter3.stream()->GetDnsAliases(), ElementsAre(kUrlC.host()));
  3109. // Verify the session pool reused the first session and no new session is
  3110. // created. This will fail unless the session pool supports multiple
  3111. // sessions aliasing a single IP.
  3112. EXPECT_EQ(1, GetQuicSessionCount(session()));
  3113. EXPECT_EQ(kProtoQUIC, request6->negotiated_protocol());
  3114. }
  3115. class ProcessAlternativeServicesTest : public TestWithTaskEnvironment {
  3116. public:
  3117. ProcessAlternativeServicesTest() {
  3118. session_params_.enable_quic = true;
  3119. session_context_.proxy_resolution_service = proxy_resolution_service_.get();
  3120. session_context_.host_resolver = &host_resolver_;
  3121. session_context_.cert_verifier = &cert_verifier_;
  3122. session_context_.transport_security_state = &transport_security_state_;
  3123. session_context_.client_socket_factory = &socket_factory_;
  3124. session_context_.ct_policy_enforcer = &ct_policy_enforcer_;
  3125. session_context_.ssl_config_service = &ssl_config_service_;
  3126. session_context_.http_server_properties = &http_server_properties_;
  3127. session_context_.quic_context = &quic_context_;
  3128. }
  3129. protected:
  3130. HttpNetworkSessionParams session_params_;
  3131. HttpNetworkSessionContext session_context_;
  3132. std::unique_ptr<HttpNetworkSession> session_;
  3133. HttpServerProperties http_server_properties_;
  3134. QuicContext quic_context_;
  3135. private:
  3136. std::unique_ptr<ProxyResolutionService> proxy_resolution_service_ =
  3137. ConfiguredProxyResolutionService::CreateDirect();
  3138. SSLConfigServiceDefaults ssl_config_service_;
  3139. MockClientSocketFactory socket_factory_;
  3140. MockHostResolver host_resolver_;
  3141. MockCertVerifier cert_verifier_;
  3142. TransportSecurityState transport_security_state_;
  3143. DefaultCTPolicyEnforcer ct_policy_enforcer_;
  3144. };
  3145. TEST_F(ProcessAlternativeServicesTest, ProcessEmptyAltSvc) {
  3146. session_ =
  3147. std::make_unique<HttpNetworkSession>(session_params_, session_context_);
  3148. url::SchemeHostPort origin;
  3149. NetworkIsolationKey network_isolation_key;
  3150. auto headers = base::MakeRefCounted<HttpResponseHeaders>("");
  3151. session_->http_stream_factory()->ProcessAlternativeServices(
  3152. session_.get(), network_isolation_key, headers.get(), origin);
  3153. AlternativeServiceInfoVector alternatives =
  3154. http_server_properties_.GetAlternativeServiceInfos(origin,
  3155. network_isolation_key);
  3156. EXPECT_TRUE(alternatives.empty());
  3157. }
  3158. TEST_F(ProcessAlternativeServicesTest, ProcessAltSvcClear) {
  3159. session_ =
  3160. std::make_unique<HttpNetworkSession>(session_params_, session_context_);
  3161. url::SchemeHostPort origin(url::kHttpsScheme, "example.com", 443);
  3162. NetworkIsolationKey network_isolation_key(
  3163. SchemefulSite(GURL("https://example.com")),
  3164. SchemefulSite(GURL("https://example.com")));
  3165. http_server_properties_.SetAlternativeServices(
  3166. origin, network_isolation_key,
  3167. {AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
  3168. {kProtoQUIC, "", 443}, base::Time::Now() + base::Seconds(30),
  3169. quic::AllSupportedVersions())});
  3170. EXPECT_FALSE(http_server_properties_
  3171. .GetAlternativeServiceInfos(origin, network_isolation_key)
  3172. .empty());
  3173. auto headers = base::MakeRefCounted<HttpResponseHeaders>("");
  3174. headers->AddHeader("alt-svc", "clear");
  3175. session_->http_stream_factory()->ProcessAlternativeServices(
  3176. session_.get(), network_isolation_key, headers.get(), origin);
  3177. AlternativeServiceInfoVector alternatives =
  3178. http_server_properties_.GetAlternativeServiceInfos(origin,
  3179. network_isolation_key);
  3180. EXPECT_TRUE(alternatives.empty());
  3181. }
  3182. TEST_F(ProcessAlternativeServicesTest, ProcessAltSvcQuicIetf) {
  3183. quic_context_.params()->supported_versions = quic::AllSupportedVersions();
  3184. session_ =
  3185. std::make_unique<HttpNetworkSession>(session_params_, session_context_);
  3186. url::SchemeHostPort origin(url::kHttpsScheme, "example.com", 443);
  3187. NetworkIsolationKey network_isolation_key(
  3188. SchemefulSite(GURL("https://example.com")),
  3189. SchemefulSite(GURL("https://example.com")));
  3190. auto headers = base::MakeRefCounted<HttpResponseHeaders>("");
  3191. headers->AddHeader("alt-svc",
  3192. "h3-29=\":443\","
  3193. "h3-Q050=\":443\","
  3194. "h3-Q043=\":443\"");
  3195. session_->http_stream_factory()->ProcessAlternativeServices(
  3196. session_.get(), network_isolation_key, headers.get(), origin);
  3197. quic::ParsedQuicVersionVector versions = {
  3198. quic::ParsedQuicVersion::Draft29(),
  3199. quic::ParsedQuicVersion::Q050(),
  3200. quic::ParsedQuicVersion::Q043(),
  3201. };
  3202. AlternativeServiceInfoVector alternatives =
  3203. http_server_properties_.GetAlternativeServiceInfos(origin,
  3204. network_isolation_key);
  3205. ASSERT_EQ(versions.size(), alternatives.size());
  3206. for (size_t i = 0; i < alternatives.size(); ++i) {
  3207. EXPECT_EQ(kProtoQUIC, alternatives[i].protocol());
  3208. EXPECT_EQ(HostPortPair("example.com", 443),
  3209. alternatives[i].host_port_pair());
  3210. EXPECT_EQ(1u, alternatives[i].advertised_versions().size());
  3211. EXPECT_EQ(versions[i], alternatives[i].advertised_versions()[0]);
  3212. }
  3213. }
  3214. TEST_F(ProcessAlternativeServicesTest, ProcessAltSvcHttp2) {
  3215. quic_context_.params()->supported_versions = quic::AllSupportedVersions();
  3216. session_ =
  3217. std::make_unique<HttpNetworkSession>(session_params_, session_context_);
  3218. url::SchemeHostPort origin(url::kHttpsScheme, "example.com", 443);
  3219. NetworkIsolationKey network_isolation_key(
  3220. SchemefulSite(GURL("https://example.com")),
  3221. SchemefulSite(GURL("https://example.com")));
  3222. auto headers = base::MakeRefCounted<HttpResponseHeaders>("");
  3223. headers->AddHeader("alt-svc", "h2=\"other.example.com:443\"");
  3224. session_->http_stream_factory()->ProcessAlternativeServices(
  3225. session_.get(), network_isolation_key, headers.get(), origin);
  3226. AlternativeServiceInfoVector alternatives =
  3227. http_server_properties_.GetAlternativeServiceInfos(origin,
  3228. network_isolation_key);
  3229. ASSERT_EQ(1u, alternatives.size());
  3230. EXPECT_EQ(kProtoHTTP2, alternatives[0].protocol());
  3231. EXPECT_EQ(HostPortPair("other.example.com", 443),
  3232. alternatives[0].host_port_pair());
  3233. EXPECT_EQ(0u, alternatives[0].advertised_versions().size());
  3234. }
  3235. } // namespace
  3236. } // namespace net