network_context_unittest.cc 301 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438643964406441644264436444644564466447644864496450645164526453645464556456645764586459646064616462646364646465646664676468646964706471647264736474647564766477647864796480648164826483648464856486648764886489649064916492649364946495649664976498649965006501650265036504650565066507650865096510651165126513651465156516651765186519652065216522652365246525652665276528652965306531653265336534653565366537653865396540654165426543654465456546654765486549655065516552655365546555655665576558655965606561656265636564656565666567656865696570657165726573657465756576657765786579658065816582658365846585658665876588658965906591659265936594659565966597659865996600660166026603660466056606660766086609661066116612661366146615661666176618661966206621662266236624662566266627662866296630663166326633663466356636663766386639664066416642664366446645664666476648664966506651665266536654665566566657665866596660666166626663666466656666666766686669667066716672667366746675667666776678667966806681668266836684668566866687668866896690669166926693669466956696669766986699670067016702670367046705670667076708670967106711671267136714671567166717671867196720672167226723672467256726672767286729673067316732673367346735673667376738673967406741674267436744674567466747674867496750675167526753675467556756675767586759676067616762676367646765676667676768676967706771677267736774677567766777677867796780678167826783678467856786678767886789679067916792679367946795679667976798679968006801680268036804680568066807680868096810681168126813681468156816681768186819682068216822682368246825682668276828682968306831683268336834683568366837683868396840684168426843684468456846684768486849685068516852685368546855685668576858685968606861686268636864686568666867686868696870687168726873687468756876687768786879688068816882688368846885688668876888688968906891689268936894689568966897689868996900690169026903690469056906690769086909691069116912691369146915691669176918691969206921692269236924692569266927692869296930693169326933693469356936693769386939694069416942694369446945694669476948694969506951695269536954695569566957695869596960696169626963696469656966696769686969697069716972697369746975697669776978697969806981698269836984698569866987698869896990699169926993699469956996699769986999700070017002700370047005700670077008700970107011701270137014701570167017701870197020702170227023702470257026702770287029703070317032703370347035703670377038703970407041704270437044704570467047704870497050705170527053705470557056705770587059706070617062706370647065706670677068706970707071707270737074707570767077707870797080708170827083708470857086708770887089709070917092709370947095709670977098709971007101710271037104710571067107710871097110711171127113711471157116711771187119712071217122712371247125712671277128712971307131713271337134713571367137713871397140714171427143714471457146714771487149715071517152715371547155715671577158715971607161716271637164716571667167716871697170717171727173717471757176717771787179718071817182718371847185718671877188718971907191719271937194719571967197719871997200720172027203720472057206720772087209721072117212721372147215721672177218721972207221722272237224722572267227722872297230723172327233723472357236723772387239724072417242724372447245724672477248724972507251725272537254725572567257725872597260726172627263726472657266726772687269727072717272727372747275727672777278727972807281728272837284728572867287728872897290729172927293729472957296729772987299730073017302730373047305730673077308730973107311731273137314731573167317731873197320732173227323732473257326732773287329733073317332733373347335733673377338733973407341734273437344734573467347734873497350735173527353735473557356735773587359736073617362736373647365736673677368736973707371737273737374737573767377737873797380738173827383738473857386738773887389739073917392739373947395739673977398739974007401740274037404740574067407740874097410741174127413741474157416741774187419742074217422742374247425742674277428742974307431743274337434743574367437743874397440744174427443744474457446744774487449745074517452745374547455745674577458745974607461746274637464746574667467746874697470747174727473747474757476747774787479748074817482748374847485748674877488748974907491749274937494
  1. // Copyright 2017 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 "services/network/network_context.h"
  5. #include <algorithm>
  6. #include <map>
  7. #include <memory>
  8. #include <string>
  9. #include <utility>
  10. #include <vector>
  11. #include "base/barrier_closure.h"
  12. #include "base/bind.h"
  13. #include "base/callback_helpers.h"
  14. #include "base/command_line.h"
  15. #include "base/containers/contains.h"
  16. #include "base/containers/span.h"
  17. #include "base/files/file.h"
  18. #include "base/files/file_path.h"
  19. #include "base/files/file_util.h"
  20. #include "base/files/scoped_temp_dir.h"
  21. #include "base/location.h"
  22. #include "base/memory/raw_ptr.h"
  23. #include "base/metrics/field_trial.h"
  24. #include "base/power_monitor/power_monitor.h"
  25. #include "base/power_monitor/power_monitor_source.h"
  26. #include "base/run_loop.h"
  27. #include "base/strings/strcat.h"
  28. #include "base/strings/string_split.h"
  29. #include "base/strings/stringprintf.h"
  30. #include "base/strings/utf_string_conversions.h"
  31. #include "base/synchronization/waitable_event.h"
  32. #include "base/test/bind.h"
  33. #include "base/test/gtest_util.h"
  34. #include "base/test/metrics/histogram_tester.h"
  35. #include "base/test/mock_entropy_provider.h"
  36. #include "base/test/scoped_feature_list.h"
  37. #include "base/test/simple_test_clock.h"
  38. #include "base/test/task_environment.h"
  39. #include "base/threading/thread_restrictions.h"
  40. #include "base/threading/thread_task_runner_handle.h"
  41. #include "base/time/default_clock.h"
  42. #include "base/time/default_tick_clock.h"
  43. #include "base/time/time.h"
  44. #include "build/build_config.h"
  45. #include "build/chromeos_buildflags.h"
  46. #include "components/network_session_configurator/browser/network_session_configurator.h"
  47. #include "components/network_session_configurator/common/network_switches.h"
  48. #include "components/prefs/testing_pref_service.h"
  49. #include "crypto/sha2.h"
  50. #include "mojo/public/cpp/bindings/self_owned_receiver.h"
  51. #include "mojo/public/cpp/system/data_pipe_utils.h"
  52. #include "mojo/public/cpp/system/functions.h"
  53. #include "net/base/cache_type.h"
  54. #include "net/base/features.h"
  55. #include "net/base/hash_value.h"
  56. #include "net/base/host_port_pair.h"
  57. #include "net/base/http_user_agent_settings.h"
  58. #include "net/base/ip_endpoint.h"
  59. #include "net/base/isolation_info.h"
  60. #include "net/base/net_errors.h"
  61. #include "net/base/network_change_notifier.h"
  62. #include "net/base/network_isolation_key.h"
  63. #include "net/base/proxy_server.h"
  64. #include "net/base/proxy_string_util.h"
  65. #include "net/base/test_completion_callback.h"
  66. #include "net/cert/cert_verify_result.h"
  67. #include "net/cert/mock_cert_verifier.h"
  68. #include "net/cert/sct_status_flags.h"
  69. #include "net/cert/x509_certificate.h"
  70. #include "net/cookies/canonical_cookie.h"
  71. #include "net/cookies/cookie_access_result.h"
  72. #include "net/cookies/cookie_options.h"
  73. #include "net/cookies/cookie_store.h"
  74. #include "net/cookies/cookie_util.h"
  75. #include "net/disk_cache/cache_util.h"
  76. #include "net/disk_cache/disk_cache.h"
  77. #include "net/disk_cache/memory/mem_backend_impl.h"
  78. #include "net/dns/context_host_resolver.h"
  79. #include "net/dns/dns_test_util.h"
  80. #include "net/dns/host_resolver_manager.h"
  81. #include "net/dns/mock_host_resolver.h"
  82. #include "net/dns/public/dns_query_type.h"
  83. #include "net/dns/public/host_resolver_source.h"
  84. #include "net/dns/public/secure_dns_policy.h"
  85. #include "net/dns/resolve_context.h"
  86. #include "net/http/http_auth.h"
  87. #include "net/http/http_cache.h"
  88. #include "net/http/http_network_session.h"
  89. #include "net/http/http_server_properties_manager.h"
  90. #include "net/http/http_transaction_factory.h"
  91. #include "net/http/http_transaction_test_util.h"
  92. #include "net/http/mock_http_cache.h"
  93. #include "net/http/transport_security_state.h"
  94. #include "net/http/transport_security_state_test_util.h"
  95. #include "net/nqe/network_quality_estimator_test_util.h"
  96. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  97. #include "net/proxy_resolution/proxy_config.h"
  98. #include "net/proxy_resolution/proxy_info.h"
  99. #include "net/socket/client_socket_pool.h"
  100. #include "net/socket/transport_client_socket_pool.h"
  101. #include "net/test/cert_test_util.h"
  102. #include "net/test/embedded_test_server/controllable_http_response.h"
  103. #include "net/test/embedded_test_server/default_handlers.h"
  104. #include "net/test/embedded_test_server/embedded_test_server.h"
  105. #include "net/test/embedded_test_server/embedded_test_server_connection_listener.h"
  106. #include "net/test/gtest_util.h"
  107. #include "net/test/spawned_test_server/spawned_test_server.h"
  108. #include "net/test/test_data_directory.h"
  109. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  110. #include "net/url_request/referrer_policy.h"
  111. #include "net/url_request/url_request_context.h"
  112. #include "net/url_request/url_request_context_builder.h"
  113. #include "net/url_request/url_request_job_factory.h"
  114. #include "net/url_request/url_request_test_util.h"
  115. #include "services/network/cookie_manager.h"
  116. #include "services/network/net_log_exporter.h"
  117. #include "services/network/network_qualities_pref_delegate.h"
  118. #include "services/network/network_service.h"
  119. #include "services/network/public/cpp/features.h"
  120. #include "services/network/public/cpp/network_service_buildflags.h"
  121. #include "services/network/public/cpp/resolve_host_client_base.h"
  122. #include "services/network/public/mojom/host_resolver.mojom.h"
  123. #include "services/network/public/mojom/net_log.mojom.h"
  124. #include "services/network/public/mojom/network_context.mojom.h"
  125. #include "services/network/public/mojom/network_service.mojom.h"
  126. #include "services/network/public/mojom/proxy_config.mojom.h"
  127. #include "services/network/public/mojom/url_loader.mojom-shared.h"
  128. #include "services/network/test/fake_test_cert_verifier_params_factory.h"
  129. #include "services/network/test/test_url_loader_client.h"
  130. #include "services/network/test/test_utils.h"
  131. #include "services/network/test/udp_socket_test_util.h"
  132. #include "services/network/test_mojo_proxy_resolver_factory.h"
  133. #include "services/network/trust_tokens/pending_trust_token_store.h"
  134. #include "services/network/trust_tokens/trust_token_parameterization.h"
  135. #include "services/network/trust_tokens/trust_token_store.h"
  136. #include "services/network/url_request_context_builder_mojo.h"
  137. #include "testing/gmock/include/gmock/gmock.h"
  138. #include "testing/gtest/include/gtest/gtest.h"
  139. #include "third_party/abseil-cpp/absl/types/optional.h"
  140. #include "url/gurl.h"
  141. #include "url/scheme_host_port.h"
  142. #include "url/url_constants.h"
  143. #if BUILDFLAG(IS_CT_SUPPORTED)
  144. #include "components/certificate_transparency/chrome_ct_policy_enforcer.h"
  145. #include "services/network/public/mojom/ct_log_info.mojom.h"
  146. #endif
  147. #if BUILDFLAG(ENABLE_REPORTING)
  148. #include "net/network_error_logging/network_error_logging_service.h"
  149. #include "net/reporting/reporting_cache.h"
  150. #include "net/reporting/reporting_context.h"
  151. #include "net/reporting/reporting_report.h"
  152. #include "net/reporting/reporting_service.h"
  153. #include "net/reporting/reporting_test_util.h"
  154. #endif // BUILDFLAG(ENABLE_REPORTING)
  155. #if BUILDFLAG(IS_CHROMEOS_ASH)
  156. #include "services/network/mock_mojo_dhcp_wpad_url_client.h"
  157. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  158. #if BUILDFLAG(IS_P2P_ENABLED)
  159. #include "services/network/public/mojom/p2p.mojom.h"
  160. #include "services/network/public/mojom/p2p_trusted.mojom.h"
  161. #endif // BUILDFLAG(IS_P2P_ENABLED)
  162. namespace network {
  163. namespace {
  164. using net::CreateTestURLRequestContextBuilder;
  165. using ::testing::Optional;
  166. constexpr char kMockHost[] = "mock.host";
  167. #if BUILDFLAG(ENABLE_REPORTING)
  168. const base::FilePath::CharType kFilename[] =
  169. FILE_PATH_LITERAL("TempReportingAndNelStore");
  170. #endif // BUILDFLAG(ENABLE_REPORTING)
  171. #if BUILDFLAG(IS_CT_SUPPORTED)
  172. void StoreBool(bool* result, base::OnceClosure callback, bool value) {
  173. *result = value;
  174. std::move(callback).Run();
  175. }
  176. #endif // BUILDFLAG(IS_CT_SUPPORTED)
  177. void StoreValue(base::Value::Dict* result,
  178. base::OnceClosure callback,
  179. base::Value::Dict value) {
  180. *result = std::move(value);
  181. std::move(callback).Run();
  182. }
  183. void SetContentSetting(const GURL& primary_pattern,
  184. const GURL& secondary_pattern,
  185. ContentSetting setting,
  186. NetworkContext* network_context) {
  187. network_context->cookie_manager()->SetContentSettings(
  188. {ContentSettingPatternSource(
  189. ContentSettingsPattern::FromURL(primary_pattern),
  190. ContentSettingsPattern::FromURL(secondary_pattern),
  191. base::Value(setting), std::string(), false)});
  192. }
  193. void SetDefaultContentSetting(ContentSetting setting,
  194. NetworkContext* network_context) {
  195. network_context->cookie_manager()->SetContentSettings(
  196. {ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
  197. ContentSettingsPattern::Wildcard(),
  198. base::Value(setting), std::string(),
  199. false)});
  200. }
  201. std::unique_ptr<TestURLLoaderClient> FetchRequest(
  202. const ResourceRequest& request,
  203. NetworkContext* network_context,
  204. int url_loader_options = mojom::kURLLoadOptionNone,
  205. int process_id = mojom::kBrowserProcessId,
  206. mojom::URLLoaderFactoryParamsPtr params = nullptr) {
  207. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  208. if (!params)
  209. params = mojom::URLLoaderFactoryParams::New();
  210. params->process_id = process_id;
  211. params->is_corb_enabled = false;
  212. // If |site_for_cookies| is null, any non-empty NIK is fine. Otherwise, the
  213. // NIK must be consistent with |site_for_cookies|.
  214. if (request.site_for_cookies.IsNull()) {
  215. params->isolation_info = net::IsolationInfo::Create(
  216. net::IsolationInfo::RequestType::kOther,
  217. url::Origin::Create(GURL("https://abc.com")),
  218. url::Origin::Create(GURL("https://xyz.com")), request.site_for_cookies);
  219. } else {
  220. params->isolation_info = net::IsolationInfo::CreateForInternalRequest(
  221. url::Origin::Create(request.site_for_cookies.RepresentativeUrl()));
  222. }
  223. network_context->CreateURLLoaderFactory(
  224. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  225. auto client = std::make_unique<TestURLLoaderClient>();
  226. mojo::PendingRemote<mojom::URLLoader> loader;
  227. loader_factory->CreateLoaderAndStart(
  228. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  229. url_loader_options, request, client->CreateRemote(),
  230. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  231. client->RunUntilComplete();
  232. return client;
  233. }
  234. // proxy_resolver::mojom::ProxyResolverFactory that captures the most recent PAC
  235. // script passed to it, and the most recent URL/NetworkIsolationKey passed to
  236. // the GetProxyForUrl() method of proxy_resolver::mojom::ProxyResolver it
  237. // returns.
  238. class CapturingMojoProxyResolverFactory
  239. : public proxy_resolver::mojom::ProxyResolverFactory,
  240. public proxy_resolver::mojom::ProxyResolver {
  241. public:
  242. CapturingMojoProxyResolverFactory() {}
  243. CapturingMojoProxyResolverFactory(const CapturingMojoProxyResolverFactory&) =
  244. delete;
  245. CapturingMojoProxyResolverFactory& operator=(
  246. const CapturingMojoProxyResolverFactory&) = delete;
  247. ~CapturingMojoProxyResolverFactory() override {}
  248. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverFactory>
  249. CreateFactoryRemote() {
  250. return proxy_factory_receiver_.BindNewPipeAndPassRemote();
  251. }
  252. // proxy_resolver::mojom::ProxyResolverFactory:
  253. void CreateResolver(
  254. const std::string& pac_script,
  255. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver,
  256. mojo::PendingRemote<
  257. proxy_resolver::mojom::ProxyResolverFactoryRequestClient> client)
  258. override {
  259. pac_script_ = pac_script;
  260. mojo::Remote<proxy_resolver::mojom::ProxyResolverFactoryRequestClient>
  261. factory_request_client(std::move(client));
  262. proxy_resolver_receiver_.Bind(std::move(receiver));
  263. factory_request_client->ReportResult(net::OK);
  264. }
  265. // proxy_resolver::mojom::ProxyResolver:
  266. void GetProxyForUrl(
  267. const GURL& url,
  268. const net::NetworkIsolationKey& network_isolation_key,
  269. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverRequestClient>
  270. client) override {
  271. url_ = url;
  272. network_isolation_key_ = network_isolation_key;
  273. mojo::Remote<proxy_resolver::mojom::ProxyResolverRequestClient>
  274. resolver_request_client(std::move(client));
  275. net::ProxyInfo proxy_info;
  276. proxy_info.UseDirect();
  277. resolver_request_client->ReportResult(net::OK, proxy_info);
  278. }
  279. const std::string& pac_script() const { return pac_script_; }
  280. // Return the GURL and NetworkIsolationKey passed to the most recent
  281. // GetProxyForUrl() call.
  282. const GURL& url() const { return url_; }
  283. const net::NetworkIsolationKey& network_isolation_key() const {
  284. return network_isolation_key_;
  285. }
  286. private:
  287. mojo::Receiver<ProxyResolverFactory> proxy_factory_receiver_{this};
  288. mojo::Receiver<ProxyResolver> proxy_resolver_receiver_{this};
  289. std::string pac_script_;
  290. GURL url_;
  291. net::NetworkIsolationKey network_isolation_key_;
  292. };
  293. // ProxyLookupClient that drives proxy lookups and can wait for the responses to
  294. // be received.
  295. class TestProxyLookupClient : public mojom::ProxyLookupClient {
  296. public:
  297. TestProxyLookupClient() = default;
  298. TestProxyLookupClient(const TestProxyLookupClient&) = delete;
  299. TestProxyLookupClient& operator=(const TestProxyLookupClient&) = delete;
  300. ~TestProxyLookupClient() override = default;
  301. void StartLookUpProxyForURL(
  302. const GURL& url,
  303. const net::NetworkIsolationKey& network_isolation_key,
  304. mojom::NetworkContext* network_context) {
  305. // Make sure this method is called at most once.
  306. EXPECT_FALSE(receiver_.is_bound());
  307. network_context->LookUpProxyForURL(url, network_isolation_key,
  308. receiver_.BindNewPipeAndPassRemote());
  309. }
  310. void WaitForResult() { run_loop_.Run(); }
  311. // mojom::ProxyLookupClient implementation:
  312. void OnProxyLookupComplete(
  313. int32_t net_error,
  314. const absl::optional<net::ProxyInfo>& proxy_info) override {
  315. EXPECT_FALSE(is_done_);
  316. EXPECT_FALSE(proxy_info_);
  317. EXPECT_EQ(net_error == net::OK, proxy_info.has_value());
  318. is_done_ = true;
  319. proxy_info_ = proxy_info;
  320. net_error_ = net_error;
  321. receiver_.reset();
  322. run_loop_.Quit();
  323. }
  324. const absl::optional<net::ProxyInfo>& proxy_info() const {
  325. return proxy_info_;
  326. }
  327. int32_t net_error() const { return net_error_; }
  328. bool is_done() const { return is_done_; }
  329. private:
  330. mojo::Receiver<mojom::ProxyLookupClient> receiver_{this};
  331. bool is_done_ = false;
  332. absl::optional<net::ProxyInfo> proxy_info_;
  333. int32_t net_error_ = net::ERR_UNEXPECTED;
  334. base::RunLoop run_loop_;
  335. };
  336. #if BUILDFLAG(IS_P2P_ENABLED)
  337. class MockP2PTrustedSocketManagerClient
  338. : public mojom::P2PTrustedSocketManagerClient {
  339. public:
  340. MockP2PTrustedSocketManagerClient() = default;
  341. ~MockP2PTrustedSocketManagerClient() override = default;
  342. // mojom::P2PTrustedSocketManagerClient:
  343. void InvalidSocketPortRangeRequested() override {}
  344. void DumpPacket(const std::vector<uint8_t>& packet_header,
  345. uint64_t packet_length,
  346. bool incoming) override {}
  347. };
  348. #endif // BUILDFLAG(IS_P2P_ENABLED)
  349. class HostResolverFactory final : public net::HostResolver::Factory {
  350. public:
  351. explicit HostResolverFactory(std::unique_ptr<net::HostResolver> resolver)
  352. : resolver_(std::move(resolver)) {}
  353. std::unique_ptr<net::HostResolver> CreateResolver(
  354. net::HostResolverManager* manager,
  355. base::StringPiece host_mapping_rules,
  356. bool enable_caching) override {
  357. DCHECK(resolver_);
  358. return std::move(resolver_);
  359. }
  360. // See HostResolver::CreateStandaloneResolver.
  361. std::unique_ptr<net::HostResolver> CreateStandaloneResolver(
  362. net::NetLog* net_log,
  363. const net::HostResolver::ManagerOptions& options,
  364. base::StringPiece host_mapping_rules,
  365. bool enable_caching) override {
  366. NOTREACHED();
  367. return nullptr;
  368. }
  369. private:
  370. std::unique_ptr<net::HostResolver> resolver_;
  371. };
  372. class NetworkContextTest : public testing::Test {
  373. public:
  374. explicit NetworkContextTest(
  375. base::test::TaskEnvironment::TimeSource time_source =
  376. base::test::TaskEnvironment::TimeSource::DEFAULT)
  377. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO,
  378. time_source),
  379. network_change_notifier_(
  380. net::NetworkChangeNotifier::CreateMockIfNeeded()),
  381. network_service_(NetworkService::CreateForTesting()) {}
  382. ~NetworkContextTest() override {}
  383. std::unique_ptr<NetworkContext> CreateContextWithParams(
  384. mojom::NetworkContextParamsPtr context_params
  385. #if BUILDFLAG(ENABLE_REPORTING)
  386. ,
  387. std::unique_ptr<net::ReportingService> reporting_service = nullptr
  388. #endif
  389. ) {
  390. // Use a dummy CertVerifier that always passes cert verification, since
  391. // these unittests don't need to test CertVerifier behavior.
  392. DCHECK(!context_params->cert_verifier_params);
  393. context_params->cert_verifier_params =
  394. FakeTestCertVerifierParamsFactory::GetCertVerifierParams();
  395. network_context_remote_.reset();
  396. return NetworkContext::CreateForTesting(
  397. network_service_.get(),
  398. network_context_remote_.BindNewPipeAndPassReceiver(),
  399. std::move(context_params),
  400. base::BindLambdaForTesting([&](net::URLRequestContextBuilder* builder) {
  401. #if BUILDFLAG(ENABLE_REPORTING)
  402. builder->set_reporting_service(std::move(reporting_service));
  403. #endif
  404. }));
  405. }
  406. // Searches through |backend|'s stats to discover its type. Only supports
  407. // blockfile and simple caches.
  408. net::URLRequestContextBuilder::HttpCacheParams::Type GetBackendType(
  409. disk_cache::Backend* backend) {
  410. base::StringPairs stats;
  411. backend->GetStats(&stats);
  412. for (const auto& pair : stats) {
  413. if (pair.first != "Cache type")
  414. continue;
  415. if (pair.second == "Simple Cache")
  416. return net::URLRequestContextBuilder::HttpCacheParams::DISK_SIMPLE;
  417. if (pair.second == "Blockfile Cache")
  418. return net::URLRequestContextBuilder::HttpCacheParams::DISK_BLOCKFILE;
  419. break;
  420. }
  421. NOTREACHED();
  422. return net::URLRequestContextBuilder::HttpCacheParams::IN_MEMORY;
  423. }
  424. mojom::NetworkService* network_service() const {
  425. return network_service_.get();
  426. }
  427. // Looks up a value with the given name from the NetworkContext's
  428. // TransportSocketPool info dictionary.
  429. int GetSocketPoolInfo(NetworkContext* context, base::StringPiece name) {
  430. return context->url_request_context()
  431. ->http_transaction_factory()
  432. ->GetSession()
  433. ->GetSocketPool(
  434. net::HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL,
  435. net::ProxyServer::Direct())
  436. ->GetInfoAsValue("", "")
  437. .FindIntPath(name)
  438. .value_or(-1);
  439. }
  440. int GetSocketCountForGroup(NetworkContext* context,
  441. const net::ClientSocketPool::GroupId& group) {
  442. base::Value pool_info =
  443. context->url_request_context()
  444. ->http_transaction_factory()
  445. ->GetSession()
  446. ->GetSocketPool(
  447. net::HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL,
  448. net::ProxyServer::Direct())
  449. ->GetInfoAsValue("", "");
  450. int count = 0;
  451. base::Value* active_socket_count = pool_info.FindPathOfType(
  452. base::span<const base::StringPiece>{
  453. {"groups", group.ToString(), "active_socket_count"}},
  454. base::Value::Type::INTEGER);
  455. if (active_socket_count)
  456. count += active_socket_count->GetInt();
  457. base::Value* idle_sockets = pool_info.FindPathOfType(
  458. base::span<const base::StringPiece>{
  459. {"groups", group.ToString(), "idle_sockets"}},
  460. base::Value::Type::LIST);
  461. if (idle_sockets)
  462. count += idle_sockets->GetListDeprecated().size();
  463. base::Value* connect_jobs = pool_info.FindPathOfType(
  464. base::span<const base::StringPiece>{
  465. {"groups", group.ToString(), "connect_jobs"}},
  466. base::Value::Type::LIST);
  467. if (connect_jobs)
  468. count += connect_jobs->GetListDeprecated().size();
  469. return count;
  470. }
  471. GURL GetHttpUrlFromHttps(const GURL& https_url) {
  472. GURL::Replacements replacements;
  473. replacements.SetSchemeStr("http");
  474. return https_url.ReplaceComponents(replacements);
  475. }
  476. protected:
  477. base::test::TaskEnvironment task_environment_;
  478. std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
  479. std::unique_ptr<NetworkService> network_service_;
  480. // Stores the mojo::Remote<NetworkContext> of the most recently created
  481. // NetworkContext. Not strictly needed, but seems best to mimic real-world
  482. // usage.
  483. mojo::Remote<mojom::NetworkContext> network_context_remote_;
  484. };
  485. class NetworkContextTestWithMockTime : public NetworkContextTest {
  486. public:
  487. NetworkContextTestWithMockTime()
  488. : NetworkContextTest(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {
  489. }
  490. };
  491. TEST_F(NetworkContextTest, DestroyContextWithLiveRequest) {
  492. net::EmbeddedTestServer test_server;
  493. test_server.AddDefaultHandlers(
  494. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  495. ASSERT_TRUE(test_server.Start());
  496. std::unique_ptr<NetworkContext> network_context =
  497. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  498. ResourceRequest request;
  499. request.url = test_server.GetURL("/hung-after-headers");
  500. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  501. mojom::URLLoaderFactoryParamsPtr params =
  502. mojom::URLLoaderFactoryParams::New();
  503. params->process_id = mojom::kBrowserProcessId;
  504. params->is_corb_enabled = false;
  505. network_context->CreateURLLoaderFactory(
  506. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  507. mojo::PendingRemote<mojom::URLLoader> loader;
  508. TestURLLoaderClient client;
  509. loader_factory->CreateLoaderAndStart(
  510. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  511. 0 /* options */, request, client.CreateRemote(),
  512. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  513. client.RunUntilResponseReceived();
  514. EXPECT_TRUE(client.has_received_response());
  515. EXPECT_FALSE(client.has_received_completion());
  516. // Destroying the loader factory should not delete the URLLoader.
  517. loader_factory.reset();
  518. base::RunLoop().RunUntilIdle();
  519. EXPECT_FALSE(client.has_received_completion());
  520. // Destroying the NetworkContext should result in destroying the loader and
  521. // the client receiving a connection error.
  522. network_context.reset();
  523. client.RunUntilDisconnect();
  524. EXPECT_FALSE(client.has_received_completion());
  525. }
  526. TEST_F(NetworkContextTest, DisableQuic) {
  527. base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableQuic);
  528. std::unique_ptr<NetworkContext> network_context =
  529. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  530. // By default, QUIC should be enabled for new NetworkContexts when the command
  531. // line indicates it should be.
  532. EXPECT_TRUE(network_context->url_request_context()
  533. ->http_transaction_factory()
  534. ->GetSession()
  535. ->params()
  536. .enable_quic);
  537. // Disabling QUIC should disable it on existing NetworkContexts.
  538. network_service()->DisableQuic();
  539. EXPECT_FALSE(network_context->url_request_context()
  540. ->http_transaction_factory()
  541. ->GetSession()
  542. ->params()
  543. .enable_quic);
  544. // Disabling QUIC should disable it new NetworkContexts.
  545. std::unique_ptr<NetworkContext> network_context2 =
  546. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  547. EXPECT_FALSE(network_context2->url_request_context()
  548. ->http_transaction_factory()
  549. ->GetSession()
  550. ->params()
  551. .enable_quic);
  552. // Disabling QUIC again should be harmless.
  553. network_service()->DisableQuic();
  554. std::unique_ptr<NetworkContext> network_context3 =
  555. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  556. EXPECT_FALSE(network_context3->url_request_context()
  557. ->http_transaction_factory()
  558. ->GetSession()
  559. ->params()
  560. .enable_quic);
  561. }
  562. TEST_F(NetworkContextTest, UserAgentAndLanguage) {
  563. const char kUserAgent[] = "Chromium Unit Test";
  564. const char kAcceptLanguage[] = "en-US,en;q=0.9,uk;q=0.8";
  565. mojom::NetworkContextParamsPtr params =
  566. CreateNetworkContextParamsForTesting();
  567. params->user_agent = kUserAgent;
  568. // Not setting accept_language, to test the default.
  569. std::unique_ptr<NetworkContext> network_context =
  570. CreateContextWithParams(std::move(params));
  571. EXPECT_EQ(kUserAgent, network_context->url_request_context()
  572. ->http_user_agent_settings()
  573. ->GetUserAgent());
  574. EXPECT_EQ("", network_context->url_request_context()
  575. ->http_user_agent_settings()
  576. ->GetAcceptLanguage());
  577. // Change accept-language.
  578. network_context->SetAcceptLanguage(kAcceptLanguage);
  579. EXPECT_EQ(kUserAgent, network_context->url_request_context()
  580. ->http_user_agent_settings()
  581. ->GetUserAgent());
  582. EXPECT_EQ(kAcceptLanguage, network_context->url_request_context()
  583. ->http_user_agent_settings()
  584. ->GetAcceptLanguage());
  585. // Create with custom accept-language configured.
  586. params = CreateNetworkContextParamsForTesting();
  587. params->user_agent = kUserAgent;
  588. params->accept_language = kAcceptLanguage;
  589. std::unique_ptr<NetworkContext> network_context2 =
  590. CreateContextWithParams(std::move(params));
  591. EXPECT_EQ(kUserAgent, network_context2->url_request_context()
  592. ->http_user_agent_settings()
  593. ->GetUserAgent());
  594. EXPECT_EQ(kAcceptLanguage, network_context2->url_request_context()
  595. ->http_user_agent_settings()
  596. ->GetAcceptLanguage());
  597. }
  598. TEST_F(NetworkContextTest, EnableBrotli) {
  599. for (bool enable_brotli : {true, false}) {
  600. mojom::NetworkContextParamsPtr context_params =
  601. CreateNetworkContextParamsForTesting();
  602. context_params->enable_brotli = enable_brotli;
  603. std::unique_ptr<NetworkContext> network_context =
  604. CreateContextWithParams(std::move(context_params));
  605. EXPECT_EQ(enable_brotli,
  606. network_context->url_request_context()->enable_brotli());
  607. }
  608. }
  609. TEST_F(NetworkContextTest, QuicUserAgentId) {
  610. const char kQuicUserAgentId[] = "007";
  611. mojom::NetworkContextParamsPtr context_params =
  612. CreateNetworkContextParamsForTesting();
  613. context_params->quic_user_agent_id = kQuicUserAgentId;
  614. std::unique_ptr<NetworkContext> network_context =
  615. CreateContextWithParams(std::move(context_params));
  616. EXPECT_EQ(kQuicUserAgentId, network_context->url_request_context()
  617. ->quic_context()
  618. ->params()
  619. ->user_agent_id);
  620. }
  621. TEST_F(NetworkContextTest, UnhandedProtocols) {
  622. const GURL kUnsupportedUrls[] = {
  623. // These are handled outside the network service.
  624. GURL("data:,foo"),
  625. GURL("file:///not/a/path/that/leads/anywhere/but/it/should/not/matter/"
  626. "anyways"),
  627. // FTP is not supported natively by Chrome.
  628. GURL("ftp://foo.test/"),
  629. };
  630. for (const GURL& url : kUnsupportedUrls) {
  631. mojom::NetworkContextParamsPtr context_params =
  632. CreateNetworkContextParamsForTesting();
  633. std::unique_ptr<NetworkContext> network_context =
  634. CreateContextWithParams(std::move(context_params));
  635. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  636. mojom::URLLoaderFactoryParamsPtr params =
  637. mojom::URLLoaderFactoryParams::New();
  638. params->process_id = mojom::kBrowserProcessId;
  639. params->is_corb_enabled = false;
  640. network_context->CreateURLLoaderFactory(
  641. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  642. mojo::PendingRemote<mojom::URLLoader> loader;
  643. TestURLLoaderClient client;
  644. ResourceRequest request;
  645. request.url = url;
  646. loader_factory->CreateLoaderAndStart(
  647. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  648. 0 /* options */, request, client.CreateRemote(),
  649. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  650. client.RunUntilComplete();
  651. EXPECT_TRUE(client.has_received_completion());
  652. EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME,
  653. client.completion_status().error_code);
  654. }
  655. }
  656. #if BUILDFLAG(ENABLE_REPORTING)
  657. TEST_F(NetworkContextTest, DisableReporting) {
  658. base::test::ScopedFeatureList scoped_feature_list_;
  659. scoped_feature_list_.InitAndDisableFeature(features::kReporting);
  660. std::unique_ptr<NetworkContext> network_context =
  661. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  662. EXPECT_FALSE(network_context->url_request_context()->reporting_service());
  663. }
  664. TEST_F(NetworkContextTest, EnableReportingWithoutStore) {
  665. base::test::ScopedFeatureList scoped_feature_list_;
  666. scoped_feature_list_.InitAndEnableFeature(features::kReporting);
  667. std::unique_ptr<NetworkContext> network_context =
  668. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  669. EXPECT_TRUE(network_context->url_request_context()->reporting_service());
  670. EXPECT_FALSE(network_context->url_request_context()
  671. ->reporting_service()
  672. ->GetContextForTesting()
  673. ->store());
  674. }
  675. TEST_F(NetworkContextTest, EnableReportingWithStore) {
  676. base::test::ScopedFeatureList scoped_feature_list_;
  677. scoped_feature_list_.InitAndEnableFeature(features::kReporting);
  678. mojom::NetworkContextParamsPtr context_params =
  679. CreateNetworkContextParamsForTesting();
  680. base::ScopedTempDir temp_dir;
  681. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  682. base::FilePath database_path = temp_dir.GetPath().Append(kFilename);
  683. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  684. context_params->file_paths->data_directory = database_path.DirName();
  685. context_params->file_paths->reporting_and_nel_store_database_name =
  686. database_path.BaseName();
  687. std::unique_ptr<NetworkContext> network_context =
  688. CreateContextWithParams(std::move(context_params));
  689. EXPECT_TRUE(network_context->url_request_context()->reporting_service());
  690. EXPECT_TRUE(network_context->url_request_context()
  691. ->reporting_service()
  692. ->GetContextForTesting()
  693. ->store());
  694. }
  695. TEST_F(NetworkContextTest, DisableNetworkErrorLogging) {
  696. base::test::ScopedFeatureList scoped_feature_list_;
  697. scoped_feature_list_.InitAndDisableFeature(features::kNetworkErrorLogging);
  698. std::unique_ptr<NetworkContext> network_context =
  699. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  700. EXPECT_FALSE(
  701. network_context->url_request_context()->network_error_logging_service());
  702. }
  703. TEST_F(NetworkContextTest, EnableNetworkErrorLoggingWithoutStore) {
  704. base::test::ScopedFeatureList scoped_feature_list_;
  705. scoped_feature_list_.InitWithFeatures(
  706. {features::kNetworkErrorLogging, features::kReporting}, {});
  707. std::unique_ptr<NetworkContext> network_context =
  708. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  709. EXPECT_TRUE(
  710. network_context->url_request_context()->network_error_logging_service());
  711. EXPECT_FALSE(network_context->url_request_context()
  712. ->network_error_logging_service()
  713. ->GetPersistentNelStoreForTesting());
  714. EXPECT_FALSE(network_context->url_request_context()
  715. ->network_error_logging_service()
  716. ->GetReportingServiceForTesting()
  717. ->GetContextForTesting()
  718. ->store());
  719. }
  720. TEST_F(NetworkContextTest, EnableNetworkErrorLoggingWithStore) {
  721. base::test::ScopedFeatureList scoped_feature_list_;
  722. scoped_feature_list_.InitWithFeatures(
  723. {features::kNetworkErrorLogging, features::kReporting}, {});
  724. mojom::NetworkContextParamsPtr context_params =
  725. CreateNetworkContextParamsForTesting();
  726. base::ScopedTempDir temp_dir;
  727. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  728. base::FilePath reporting_and_nel_store = temp_dir.GetPath().Append(kFilename);
  729. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  730. context_params->file_paths->data_directory =
  731. reporting_and_nel_store.DirName();
  732. context_params->file_paths->reporting_and_nel_store_database_name =
  733. reporting_and_nel_store.BaseName();
  734. std::unique_ptr<NetworkContext> network_context =
  735. CreateContextWithParams(std::move(context_params));
  736. EXPECT_TRUE(
  737. network_context->url_request_context()->network_error_logging_service());
  738. EXPECT_TRUE(network_context->url_request_context()
  739. ->network_error_logging_service()
  740. ->GetPersistentNelStoreForTesting());
  741. EXPECT_TRUE(network_context->url_request_context()
  742. ->network_error_logging_service()
  743. ->GetReportingServiceForTesting()
  744. ->GetContextForTesting()
  745. ->store());
  746. }
  747. #endif // BUILDFLAG(ENABLE_REPORTING)
  748. TEST_F(NetworkContextTest, DefaultHttpNetworkSessionParams) {
  749. std::unique_ptr<NetworkContext> network_context =
  750. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  751. const net::HttpNetworkSessionParams& params =
  752. network_context->url_request_context()
  753. ->http_transaction_factory()
  754. ->GetSession()
  755. ->params();
  756. const net::QuicParams* quic_params =
  757. network_context->url_request_context()->quic_context()->params();
  758. EXPECT_TRUE(params.enable_http2);
  759. EXPECT_TRUE(params.enable_quic);
  760. EXPECT_EQ(1250u, quic_params->max_packet_length);
  761. EXPECT_TRUE(quic_params->origins_to_force_quic_on.empty());
  762. EXPECT_FALSE(params.enable_user_alternate_protocol_ports);
  763. EXPECT_FALSE(params.ignore_certificate_errors);
  764. EXPECT_EQ(0, params.testing_fixed_http_port);
  765. EXPECT_EQ(0, params.testing_fixed_https_port);
  766. }
  767. // Make sure that network_session_configurator is hooked up.
  768. TEST_F(NetworkContextTest, FixedHttpPort) {
  769. base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  770. switches::kTestingFixedHttpPort, "800");
  771. base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  772. switches::kTestingFixedHttpsPort, "801");
  773. std::unique_ptr<NetworkContext> network_context =
  774. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  775. const net::HttpNetworkSessionParams& params =
  776. network_context->url_request_context()
  777. ->http_transaction_factory()
  778. ->GetSession()
  779. ->params();
  780. EXPECT_EQ(800, params.testing_fixed_http_port);
  781. EXPECT_EQ(801, params.testing_fixed_https_port);
  782. }
  783. TEST_F(NetworkContextTest, NoCache) {
  784. mojom::NetworkContextParamsPtr context_params =
  785. CreateNetworkContextParamsForTesting();
  786. context_params->http_cache_enabled = false;
  787. std::unique_ptr<NetworkContext> network_context =
  788. CreateContextWithParams(std::move(context_params));
  789. EXPECT_FALSE(network_context->url_request_context()
  790. ->http_transaction_factory()
  791. ->GetCache());
  792. }
  793. TEST_F(NetworkContextTest, MemoryCache) {
  794. mojom::NetworkContextParamsPtr context_params =
  795. CreateNetworkContextParamsForTesting();
  796. context_params->http_cache_enabled = true;
  797. std::unique_ptr<NetworkContext> network_context =
  798. CreateContextWithParams(std::move(context_params));
  799. net::HttpCache* cache = network_context->url_request_context()
  800. ->http_transaction_factory()
  801. ->GetCache();
  802. ASSERT_TRUE(cache);
  803. disk_cache::Backend* backend = nullptr;
  804. net::TestCompletionCallback callback;
  805. int rv = cache->GetBackend(&backend, callback.callback());
  806. EXPECT_EQ(net::OK, callback.GetResult(rv));
  807. ASSERT_TRUE(backend);
  808. EXPECT_EQ(net::MEMORY_CACHE, backend->GetCacheType());
  809. }
  810. TEST_F(NetworkContextTest, DiskCache) {
  811. mojom::NetworkContextParamsPtr context_params =
  812. CreateNetworkContextParamsForTesting();
  813. context_params->http_cache_enabled = true;
  814. base::ScopedTempDir temp_dir;
  815. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  816. context_params->http_cache_directory = temp_dir.GetPath();
  817. std::unique_ptr<NetworkContext> network_context =
  818. CreateContextWithParams(std::move(context_params));
  819. net::HttpCache* cache = network_context->url_request_context()
  820. ->http_transaction_factory()
  821. ->GetCache();
  822. ASSERT_TRUE(cache);
  823. disk_cache::Backend* backend = nullptr;
  824. net::TestCompletionCallback callback;
  825. int rv = cache->GetBackend(&backend, callback.callback());
  826. EXPECT_EQ(net::OK, callback.GetResult(rv));
  827. ASSERT_TRUE(backend);
  828. EXPECT_EQ(net::DISK_CACHE, backend->GetCacheType());
  829. EXPECT_EQ(network_session_configurator::ChooseCacheType(),
  830. GetBackendType(backend));
  831. }
  832. class DiskCacheSizeTest : public NetworkContextTest {
  833. public:
  834. DiskCacheSizeTest() = default;
  835. ~DiskCacheSizeTest() override = default;
  836. int64_t VerifyDiskCacheSize(int scale = 100) {
  837. base::test::ScopedFeatureList scoped_feature_list;
  838. if (scale != 100) {
  839. std::map<std::string, std::string> field_trial_params;
  840. field_trial_params["percent_relative_size"] = base::NumberToString(scale);
  841. scoped_feature_list.InitAndEnableFeatureWithParameters(
  842. disk_cache::kChangeDiskCacheSizeExperiment, field_trial_params);
  843. }
  844. base::HistogramTester histogram_tester;
  845. mojom::NetworkContextParamsPtr context_params =
  846. CreateNetworkContextParamsForTesting();
  847. context_params->http_cache_enabled = true;
  848. base::ScopedTempDir temp_dir;
  849. EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
  850. context_params->http_cache_directory = temp_dir.GetPath();
  851. std::unique_ptr<NetworkContext> network_context =
  852. CreateContextWithParams(std::move(context_params));
  853. net::HttpCache* cache = network_context->url_request_context()
  854. ->http_transaction_factory()
  855. ->GetCache();
  856. EXPECT_TRUE(cache);
  857. disk_cache::Backend* backend = nullptr;
  858. net::TestCompletionCallback callback;
  859. int rv = cache->GetBackend(&backend, callback.callback());
  860. EXPECT_EQ(net::OK, callback.GetResult(rv));
  861. EXPECT_TRUE(backend);
  862. EXPECT_EQ(net::DISK_CACHE, backend->GetCacheType());
  863. int64_t max_file_size = backend->MaxFileSize();
  864. histogram_tester.ExpectTotalCount("HttpCache.MaxFileSizeOnInit", 1);
  865. histogram_tester.ExpectUniqueSample("HttpCache.MaxFileSizeOnInit",
  866. max_file_size / 1024, 1);
  867. return max_file_size;
  868. }
  869. };
  870. TEST_F(DiskCacheSizeTest, DiskCacheSize) {
  871. int64_t max_file_size = VerifyDiskCacheSize();
  872. int64_t max_file_size_scaled = VerifyDiskCacheSize(200);
  873. // After scaling to 200%, the size will in most cases be twice of
  874. // |max_file_size| but it is dependent on the available size, and since we
  875. // cannot guarantee available size to be the same between the 2 runs to
  876. // VerifyDiskCacheSize(), only checking for the scaled size to be >=
  877. // max_file_size.
  878. EXPECT_GE(max_file_size_scaled, max_file_size);
  879. }
  880. // This makes sure that network_session_configurator::ChooseCacheType is
  881. // connected to NetworkContext.
  882. TEST_F(NetworkContextTest, SimpleCache) {
  883. base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial", "ExperimentYes");
  884. mojom::NetworkContextParamsPtr context_params =
  885. CreateNetworkContextParamsForTesting();
  886. context_params->http_cache_enabled = true;
  887. base::ScopedTempDir temp_dir;
  888. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  889. context_params->http_cache_directory = temp_dir.GetPath();
  890. std::unique_ptr<NetworkContext> network_context =
  891. CreateContextWithParams(std::move(context_params));
  892. net::HttpCache* cache = network_context->url_request_context()
  893. ->http_transaction_factory()
  894. ->GetCache();
  895. ASSERT_TRUE(cache);
  896. disk_cache::Backend* backend = nullptr;
  897. net::TestCompletionCallback callback;
  898. int rv = cache->GetBackend(&backend, callback.callback());
  899. EXPECT_EQ(net::OK, callback.GetResult(rv));
  900. ASSERT_TRUE(backend);
  901. base::StringPairs stats;
  902. backend->GetStats(&stats);
  903. EXPECT_EQ(net::URLRequestContextBuilder::HttpCacheParams::DISK_SIMPLE,
  904. GetBackendType(backend));
  905. }
  906. TEST_F(NetworkContextTest, HttpServerPropertiesToDisk) {
  907. base::ScopedTempDir temp_dir;
  908. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  909. base::FilePath file_path = temp_dir.GetPath().AppendASCII("foo");
  910. EXPECT_FALSE(base::PathExists(file_path));
  911. const url::SchemeHostPort kSchemeHostPort("https", "foo", 443);
  912. // Create a context with on-disk storage of HTTP server properties.
  913. mojom::NetworkContextParamsPtr context_params =
  914. CreateNetworkContextParamsForTesting();
  915. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  916. context_params->file_paths->data_directory = file_path.DirName();
  917. context_params->file_paths->http_server_properties_file_name =
  918. file_path.BaseName();
  919. std::unique_ptr<NetworkContext> network_context =
  920. CreateContextWithParams(std::move(context_params));
  921. // Wait for properties to load from disk, and sanity check initial state.
  922. task_environment_.RunUntilIdle();
  923. EXPECT_FALSE(
  924. network_context->url_request_context()
  925. ->http_server_properties()
  926. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  927. // Set a property.
  928. network_context->url_request_context()
  929. ->http_server_properties()
  930. ->SetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey(), true);
  931. // Deleting the context will cause it to flush state. Wait for the pref
  932. // service to flush to disk.
  933. network_context.reset();
  934. task_environment_.RunUntilIdle();
  935. // Create a new NetworkContext using the same path for HTTP server properties.
  936. context_params = CreateNetworkContextParamsForTesting();
  937. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  938. context_params->file_paths->data_directory = file_path.DirName();
  939. context_params->file_paths->http_server_properties_file_name =
  940. file_path.BaseName();
  941. network_context = CreateContextWithParams(std::move(context_params));
  942. // Wait for properties to load from disk.
  943. task_environment_.RunUntilIdle();
  944. EXPECT_TRUE(
  945. network_context->url_request_context()
  946. ->http_server_properties()
  947. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  948. // Now check that ClearNetworkingHistoryBetween clears the data.
  949. base::RunLoop run_loop2;
  950. network_context->ClearNetworkingHistoryBetween(
  951. base::Time::Now() - base::Hours(1), base::Time::Max(),
  952. run_loop2.QuitClosure());
  953. run_loop2.Run();
  954. EXPECT_FALSE(
  955. network_context->url_request_context()
  956. ->http_server_properties()
  957. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  958. // Destroy the network context and let any pending writes complete before
  959. // destroying |temp_dir|, to avoid leaking any files.
  960. network_context.reset();
  961. task_environment_.RunUntilIdle();
  962. ASSERT_TRUE(temp_dir.Delete());
  963. }
  964. #if BUILDFLAG(IS_DIRECTORY_TRANSFER_REQUIRED)
  965. TEST_F(NetworkContextTest, DataDirectoryAsHandle) {
  966. base::ScopedTempDir temp_dir;
  967. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  968. base::FilePath file_path = temp_dir.GetPath().AppendASCII("foo");
  969. ASSERT_TRUE(base::CreateDirectory(file_path.DirName()));
  970. const url::SchemeHostPort kSchemeHostPort("https", "foo", 443);
  971. // Create a context with on-disk storage of HTTP server properties.
  972. mojom::NetworkContextParamsPtr context_params =
  973. CreateNetworkContextParamsForTesting();
  974. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  975. // Make |data_directory| into a path-less directory handle.
  976. // Moving a TransferableDirectory once it's been opened will drop the
  977. // path from the original.
  978. context_params->file_paths->data_directory =
  979. TransferableDirectory(file_path.DirName());
  980. context_params->file_paths->data_directory.OpenForTransfer();
  981. EXPECT_TRUE(context_params->file_paths->data_directory.NeedsMount());
  982. context_params->file_paths->http_server_properties_file_name =
  983. file_path.BaseName();
  984. std::unique_ptr<NetworkContext> network_context =
  985. CreateContextWithParams(std::move(context_params));
  986. // Wait for properties to load from disk, and sanity check initial state.
  987. task_environment_.RunUntilIdle();
  988. EXPECT_FALSE(
  989. network_context->url_request_context()
  990. ->http_server_properties()
  991. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  992. // Set a property.
  993. network_context->url_request_context()
  994. ->http_server_properties()
  995. ->SetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey(), true);
  996. // Deleting the context will cause it to flush state. Wait for the pref
  997. // service to flush to disk.
  998. network_context.reset();
  999. task_environment_.RunUntilIdle();
  1000. // Create a new NetworkContext using the same path for HTTP server properties.
  1001. context_params = CreateNetworkContextParamsForTesting();
  1002. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  1003. context_params->file_paths->data_directory = file_path.DirName();
  1004. context_params->file_paths->http_server_properties_file_name =
  1005. file_path.BaseName();
  1006. network_context = CreateContextWithParams(std::move(context_params));
  1007. // Wait for properties to load from disk.
  1008. task_environment_.RunUntilIdle();
  1009. EXPECT_TRUE(
  1010. network_context->url_request_context()
  1011. ->http_server_properties()
  1012. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  1013. // Now check that ClearNetworkingHistoryBetween clears the data.
  1014. base::RunLoop run_loop2;
  1015. network_context->ClearNetworkingHistoryBetween(
  1016. base::Time::Now() - base::Hours(1), base::Time::Max(),
  1017. run_loop2.QuitClosure());
  1018. run_loop2.Run();
  1019. EXPECT_FALSE(
  1020. network_context->url_request_context()
  1021. ->http_server_properties()
  1022. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  1023. // Destroy the network context and let any pending writes complete before
  1024. // destroying |temp_dir|, to avoid leaking any files.
  1025. network_context.reset();
  1026. task_environment_.RunUntilIdle();
  1027. ASSERT_TRUE(temp_dir.Delete());
  1028. }
  1029. #endif // BUILDFLAG(IS_DIRECTORY_TRANSFER_REQUIRED)
  1030. // Checks that ClearNetworkingHistoryBetween() clears in-memory pref stores and
  1031. // invokes the closure passed to it.
  1032. TEST_F(NetworkContextTest, ClearHttpServerPropertiesInMemory) {
  1033. const url::SchemeHostPort kSchemeHostPort("https", "foo", 443);
  1034. std::unique_ptr<NetworkContext> network_context =
  1035. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1036. EXPECT_FALSE(
  1037. network_context->url_request_context()
  1038. ->http_server_properties()
  1039. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  1040. network_context->url_request_context()
  1041. ->http_server_properties()
  1042. ->SetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey(), true);
  1043. EXPECT_TRUE(
  1044. network_context->url_request_context()
  1045. ->http_server_properties()
  1046. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  1047. base::RunLoop run_loop;
  1048. network_context->ClearNetworkingHistoryBetween(
  1049. base::Time::Now() - base::Hours(1), base::Time::Max(),
  1050. run_loop.QuitClosure());
  1051. run_loop.Run();
  1052. EXPECT_FALSE(
  1053. network_context->url_request_context()
  1054. ->http_server_properties()
  1055. ->GetSupportsSpdy(kSchemeHostPort, net::NetworkIsolationKey()));
  1056. }
  1057. // Checks that ClearNetworkingHistoryBetween() clears network quality prefs.
  1058. TEST_F(NetworkContextTest, ClearingNetworkingHistoryClearNetworkQualityPrefs) {
  1059. const url::SchemeHostPort kSchemeHostPort("https", "foo", 443);
  1060. net::TestNetworkQualityEstimator estimator;
  1061. std::unique_ptr<NetworkContext> network_context =
  1062. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1063. TestingPrefServiceSimple pref_service_simple;
  1064. NetworkQualitiesPrefDelegate::RegisterPrefs(pref_service_simple.registry());
  1065. std::unique_ptr<NetworkQualitiesPrefDelegate>
  1066. network_qualities_pref_delegate =
  1067. std::make_unique<NetworkQualitiesPrefDelegate>(&pref_service_simple,
  1068. &estimator);
  1069. NetworkQualitiesPrefDelegate* network_qualities_pref_delegate_ptr =
  1070. network_qualities_pref_delegate.get();
  1071. network_context->set_network_qualities_pref_delegate_for_testing(
  1072. std::move(network_qualities_pref_delegate));
  1073. // Running the loop allows prefs to be set.
  1074. base::RunLoop().RunUntilIdle();
  1075. EXPECT_FALSE(
  1076. network_qualities_pref_delegate_ptr->ForceReadPrefsForTesting().empty());
  1077. // Clear the networking history.
  1078. base::RunLoop run_loop;
  1079. base::HistogramTester histogram_tester;
  1080. network_context->ClearNetworkingHistoryBetween(
  1081. base::Time::Now() - base::Hours(1), base::Time::Max(),
  1082. run_loop.QuitClosure());
  1083. run_loop.Run();
  1084. // Running the loop should clear the network quality prefs.
  1085. base::RunLoop().RunUntilIdle();
  1086. // Prefs should be empty now.
  1087. EXPECT_TRUE(
  1088. network_qualities_pref_delegate_ptr->ForceReadPrefsForTesting().empty());
  1089. histogram_tester.ExpectTotalCount("NQE.PrefsSizeOnClearing", 1);
  1090. }
  1091. // Test that TransportSecurity state is persisted (or not) as expected.
  1092. TEST_F(NetworkContextTest, TransportSecurityStatePersisted) {
  1093. const char kDomain[] = "foo.test";
  1094. base::ScopedTempDir temp_dir;
  1095. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  1096. base::FilePath transport_security_persister_file_path =
  1097. temp_dir.GetPath().AppendASCII("TransportSecurity");
  1098. EXPECT_FALSE(base::PathExists(transport_security_persister_file_path));
  1099. for (bool on_disk : {false, true}) {
  1100. // Create a NetworkContext.
  1101. mojom::NetworkContextParamsPtr context_params =
  1102. CreateNetworkContextParamsForTesting();
  1103. if (on_disk) {
  1104. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  1105. context_params->file_paths->data_directory =
  1106. transport_security_persister_file_path.DirName();
  1107. context_params->file_paths->transport_security_persister_file_name =
  1108. transport_security_persister_file_path.BaseName();
  1109. }
  1110. std::unique_ptr<NetworkContext> network_context =
  1111. CreateContextWithParams(std::move(context_params));
  1112. // Add an STS entry.
  1113. net::TransportSecurityState::STSState sts_state;
  1114. net::TransportSecurityState* state =
  1115. network_context->url_request_context()->transport_security_state();
  1116. EXPECT_FALSE(state->GetDynamicSTSState(kDomain, &sts_state));
  1117. state->AddHSTS(kDomain, base::Time::Now() + base::Seconds(1000),
  1118. false /* include subdomains */);
  1119. EXPECT_TRUE(state->GetDynamicSTSState(kDomain, &sts_state));
  1120. ASSERT_EQ(kDomain, sts_state.domain);
  1121. // Destroy the network context, and wait for all tasks to write state to
  1122. // disk to finish running.
  1123. network_context.reset();
  1124. task_environment_.RunUntilIdle();
  1125. EXPECT_EQ(on_disk,
  1126. base::PathExists(transport_security_persister_file_path));
  1127. // Create a new NetworkContext,with the same parameters, and check if the
  1128. // added STS entry still exists.
  1129. context_params = CreateNetworkContextParamsForTesting();
  1130. if (on_disk) {
  1131. context_params->file_paths = mojom::NetworkContextFilePaths::New();
  1132. context_params->file_paths->data_directory =
  1133. transport_security_persister_file_path.DirName();
  1134. context_params->file_paths->transport_security_persister_file_name =
  1135. transport_security_persister_file_path.BaseName();
  1136. }
  1137. network_context = CreateContextWithParams(std::move(context_params));
  1138. // Wait for the entry to load.
  1139. task_environment_.RunUntilIdle();
  1140. state = network_context->url_request_context()->transport_security_state();
  1141. ASSERT_EQ(on_disk, state->GetDynamicSTSState(kDomain, &sts_state));
  1142. if (on_disk)
  1143. EXPECT_EQ(kDomain, sts_state.domain);
  1144. }
  1145. }
  1146. // Test that PKP failures are reported if and only if certificate reporting is
  1147. // enabled.
  1148. TEST_F(NetworkContextTest, CertReporting) {
  1149. const char kPreloadedPKPHost[] = "with-report-uri-pkp.preloaded.test";
  1150. const char kReportHost[] = "report-uri.preloaded.test";
  1151. const char kReportPath[] = "/pkp";
  1152. base::test::ScopedFeatureList scoped_feature_list_;
  1153. scoped_feature_list_.InitAndEnableFeature(
  1154. net::features::kStaticKeyPinningEnforcement);
  1155. for (bool reporting_enabled : {false, true}) {
  1156. // Server that PKP reports are sent to.
  1157. net::test_server::EmbeddedTestServer report_test_server;
  1158. net::test_server::ControllableHttpResponse controllable_response(
  1159. &report_test_server, kReportPath);
  1160. ASSERT_TRUE(report_test_server.Start());
  1161. // Configure the TransportSecurityStateSource so that kPreloadedPKPHost will
  1162. // have static PKP pins set, with a report URI on kReportHost.
  1163. net::ScopedTransportSecurityStateSource scoped_security_state_source(
  1164. report_test_server.port());
  1165. // Configure a test HTTPS server.
  1166. net::test_server::EmbeddedTestServer pkp_test_server(
  1167. net::test_server::EmbeddedTestServer::TYPE_HTTPS);
  1168. pkp_test_server.SetSSLConfig(
  1169. net::test_server::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
  1170. ASSERT_TRUE(pkp_test_server.Start());
  1171. // Configure mock cert verifier to cause the PKP check to fail.
  1172. net::CertVerifyResult result;
  1173. result.verified_cert = net::CreateCertificateChainFromFile(
  1174. net::GetTestCertsDirectory(), "ok_cert.pem",
  1175. net::X509Certificate::FORMAT_PEM_CERT_SEQUENCE);
  1176. ASSERT_TRUE(result.verified_cert);
  1177. net::SHA256HashValue hash = {{0x00, 0x01}};
  1178. result.public_key_hashes.push_back(net::HashValue(hash));
  1179. result.is_issued_by_known_root = true;
  1180. net::MockCertVerifier mock_verifier;
  1181. mock_verifier.AddResultForCert(pkp_test_server.GetCertificate(), result,
  1182. net::OK);
  1183. NetworkContext::SetCertVerifierForTesting(&mock_verifier);
  1184. // Configure a MockHostResolver to map requests to kPreloadedPKPHost and
  1185. // kReportHost to the test servers:
  1186. scoped_refptr<net::RuleBasedHostResolverProc> mock_resolver_proc =
  1187. base::MakeRefCounted<net::RuleBasedHostResolverProc>(nullptr);
  1188. mock_resolver_proc->AddIPLiteralRule(
  1189. kPreloadedPKPHost, pkp_test_server.GetIPLiteralString(), std::string());
  1190. mock_resolver_proc->AddIPLiteralRule(
  1191. kReportHost, report_test_server.GetIPLiteralString(), std::string());
  1192. net::ScopedDefaultHostResolverProc scoped_default_host_resolver(
  1193. mock_resolver_proc.get());
  1194. mojom::NetworkContextParamsPtr context_params =
  1195. CreateNetworkContextParamsForTesting();
  1196. EXPECT_FALSE(context_params->enable_certificate_reporting);
  1197. context_params->enable_certificate_reporting = reporting_enabled;
  1198. std::unique_ptr<NetworkContext> network_context =
  1199. CreateContextWithParams(std::move(context_params));
  1200. // Enable static pins so that requests made to kPreloadedPKPHost will check
  1201. // the pins, and send a report if the pinning check fails.
  1202. network_context->url_request_context()
  1203. ->transport_security_state()
  1204. ->EnableStaticPinsForTesting();
  1205. network_context->url_request_context()
  1206. ->transport_security_state()
  1207. ->SetPinningListAlwaysTimelyForTesting(true);
  1208. ResourceRequest request;
  1209. request.url = pkp_test_server.GetURL(kPreloadedPKPHost, "/");
  1210. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  1211. mojom::URLLoaderFactoryParamsPtr params =
  1212. mojom::URLLoaderFactoryParams::New();
  1213. params->process_id = mojom::kBrowserProcessId;
  1214. params->is_corb_enabled = false;
  1215. network_context->CreateURLLoaderFactory(
  1216. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  1217. mojo::PendingRemote<mojom::URLLoader> loader;
  1218. TestURLLoaderClient client;
  1219. loader_factory->CreateLoaderAndStart(
  1220. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  1221. 0 /* options */, request, client.CreateRemote(),
  1222. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  1223. client.RunUntilComplete();
  1224. EXPECT_TRUE(client.has_received_completion());
  1225. EXPECT_EQ(net::ERR_INSECURE_RESPONSE,
  1226. client.completion_status().error_code);
  1227. if (reporting_enabled) {
  1228. // If reporting is enabled, wait to see the request from the ReportSender.
  1229. // Don't respond to the request, effectively making it a hung request.
  1230. controllable_response.WaitForRequest();
  1231. } else {
  1232. // Otherwise, there should be no pending URLRequest.
  1233. // |controllable_response| will cause requests to hang, so if there's no
  1234. // URLRequest, then either a reporting request was never started. This
  1235. // relies on reported being sent immediately for correctness.
  1236. network_context->url_request_context()->AssertNoURLRequests();
  1237. }
  1238. // Destroy the network context. This serves to check the case that reporting
  1239. // requests are alive when a NetworkContext is torn down.
  1240. network_context.reset();
  1241. // Remove global reference to the MockCertVerifier before it falls out of
  1242. // scope.
  1243. NetworkContext::SetCertVerifierForTesting(nullptr);
  1244. }
  1245. }
  1246. // Test that host resolution error information is available.
  1247. TEST_F(NetworkContextTest, HostResolutionFailure) {
  1248. auto context_builder = CreateTestURLRequestContextBuilder();
  1249. std::unique_ptr<net::MockHostResolver> resolver =
  1250. std::make_unique<net::MockHostResolver>();
  1251. resolver->rules()->AddSimulatedTimeoutFailure("*");
  1252. context_builder->set_host_resolver(std::move(resolver));
  1253. auto url_request_context = context_builder->Build();
  1254. network_context_remote_.reset();
  1255. std::unique_ptr<NetworkContext> network_context =
  1256. std::make_unique<NetworkContext>(
  1257. network_service_.get(),
  1258. network_context_remote_.BindNewPipeAndPassReceiver(),
  1259. url_request_context.get(),
  1260. /*cors_exempt_header_list=*/std::vector<std::string>());
  1261. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  1262. mojom::URLLoaderFactoryParamsPtr params =
  1263. mojom::URLLoaderFactoryParams::New();
  1264. params->process_id = mojom::kBrowserProcessId;
  1265. params->is_corb_enabled = false;
  1266. network_context->CreateURLLoaderFactory(
  1267. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  1268. ResourceRequest request;
  1269. request.url = GURL("http://example.test");
  1270. mojo::PendingRemote<mojom::URLLoader> loader;
  1271. TestURLLoaderClient client;
  1272. loader_factory->CreateLoaderAndStart(
  1273. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  1274. 0 /* options */, request, client.CreateRemote(),
  1275. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  1276. client.RunUntilComplete();
  1277. EXPECT_TRUE(client.has_received_completion());
  1278. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, client.completion_status().error_code);
  1279. EXPECT_EQ(net::ERR_DNS_TIMED_OUT,
  1280. client.completion_status().resolve_error_info.error);
  1281. }
  1282. #if BUILDFLAG(IS_P2P_ENABLED)
  1283. // Test the P2PSocketManager::GetHostAddress() works and uses the correct
  1284. // NetworkIsolationKey.
  1285. TEST_F(NetworkContextTest, P2PHostResolution) {
  1286. base::test::ScopedFeatureList feature_list;
  1287. feature_list.InitAndEnableFeature(
  1288. net::features::kSplitHostCacheByNetworkIsolationKey);
  1289. const char kHostname[] = "foo.test.";
  1290. net::IPAddress ip_address;
  1291. ASSERT_TRUE(ip_address.AssignFromIPLiteral("1.2.3.4"));
  1292. net::NetworkIsolationKey network_isolation_key =
  1293. net::NetworkIsolationKey::CreateTransient();
  1294. auto context_builder = CreateTestURLRequestContextBuilder();
  1295. context_builder->set_host_resolver(
  1296. std::make_unique<net::MockCachingHostResolver>());
  1297. auto url_request_context = context_builder->Build();
  1298. auto& host_resolver = *static_cast<net::MockCachingHostResolver*>(
  1299. url_request_context->host_resolver());
  1300. host_resolver.rules()->AddRule(kHostname, ip_address.ToString());
  1301. network_context_remote_.reset();
  1302. std::unique_ptr<NetworkContext> network_context =
  1303. std::make_unique<NetworkContext>(
  1304. network_service_.get(),
  1305. network_context_remote_.BindNewPipeAndPassReceiver(),
  1306. url_request_context.get(),
  1307. std::vector<std::string>() /* cors_exempt_header_list */);
  1308. MockP2PTrustedSocketManagerClient client;
  1309. mojo::Receiver<network::mojom::P2PTrustedSocketManagerClient> receiver(
  1310. &client);
  1311. mojo::Remote<mojom::P2PTrustedSocketManager> trusted_socket_manager;
  1312. mojo::Remote<mojom::P2PSocketManager> socket_manager;
  1313. network_context_remote_->CreateP2PSocketManager(
  1314. network_isolation_key, receiver.BindNewPipeAndPassRemote(),
  1315. trusted_socket_manager.BindNewPipeAndPassReceiver(),
  1316. socket_manager.BindNewPipeAndPassReceiver());
  1317. base::RunLoop run_loop;
  1318. std::vector<net::IPAddress> results;
  1319. socket_manager->GetHostAddress(
  1320. kHostname, false /* enable_mdns */,
  1321. base::BindLambdaForTesting(
  1322. [&](const std::vector<net::IPAddress>& addresses) {
  1323. EXPECT_EQ(std::vector<net::IPAddress>{ip_address}, addresses);
  1324. run_loop.Quit();
  1325. }));
  1326. run_loop.Run();
  1327. // Check that the URL in kHostname is in the HostCache, with
  1328. // |network_isolation_key|.
  1329. const net::HostPortPair kHostPortPair = net::HostPortPair(kHostname, 0);
  1330. net::HostResolver::ResolveHostParameters params;
  1331. params.source = net::HostResolverSource::LOCAL_ONLY;
  1332. std::unique_ptr<net::HostResolver::ResolveHostRequest> request1 =
  1333. host_resolver.CreateRequest(kHostPortPair, network_isolation_key,
  1334. net::NetLogWithSource(), params);
  1335. net::TestCompletionCallback callback1;
  1336. int result = request1->Start(callback1.callback());
  1337. EXPECT_EQ(net::OK, callback1.GetResult(result));
  1338. // Check that the hostname is not in the DNS cache for other possible NIKs.
  1339. const url::Origin kDestinationOrigin =
  1340. url::Origin::Create(GURL(base::StringPrintf("https://%s", kHostname)));
  1341. const net::NetworkIsolationKey kOtherNiks[] = {
  1342. net::NetworkIsolationKey(),
  1343. net::NetworkIsolationKey(kDestinationOrigin /* top_frame_origin */,
  1344. kDestinationOrigin /* frame_origin */)};
  1345. for (const auto& other_nik : kOtherNiks) {
  1346. std::unique_ptr<net::HostResolver::ResolveHostRequest> request2 =
  1347. host_resolver.CreateRequest(kHostPortPair, other_nik,
  1348. net::NetLogWithSource(), params);
  1349. net::TestCompletionCallback callback2;
  1350. result = request2->Start(callback2.callback());
  1351. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, callback2.GetResult(result));
  1352. }
  1353. }
  1354. #endif // BUILDFLAG(IS_P2P_ENABLED)
  1355. // Test that valid referrers are allowed, while invalid ones result in errors.
  1356. TEST_F(NetworkContextTest, Referrers) {
  1357. const GURL kReferrer = GURL("http://referrer/");
  1358. net::test_server::EmbeddedTestServer test_server;
  1359. test_server.AddDefaultHandlers(
  1360. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  1361. ASSERT_TRUE(test_server.Start());
  1362. for (bool validate_referrer_policy_on_initial_request : {false, true}) {
  1363. for (net::ReferrerPolicy referrer_policy :
  1364. {net::ReferrerPolicy::NEVER_CLEAR, net::ReferrerPolicy::NO_REFERRER}) {
  1365. mojom::NetworkContextParamsPtr context_params =
  1366. CreateNetworkContextParamsForTesting();
  1367. context_params->validate_referrer_policy_on_initial_request =
  1368. validate_referrer_policy_on_initial_request;
  1369. std::unique_ptr<NetworkContext> network_context =
  1370. CreateContextWithParams(std::move(context_params));
  1371. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  1372. mojom::URLLoaderFactoryParamsPtr params =
  1373. mojom::URLLoaderFactoryParams::New();
  1374. params->process_id = 0;
  1375. network_context->CreateURLLoaderFactory(
  1376. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  1377. ResourceRequest request;
  1378. request.url = test_server.GetURL("/echoheader?Referer");
  1379. request.referrer = kReferrer;
  1380. request.referrer_policy = referrer_policy;
  1381. mojo::PendingRemote<mojom::URLLoader> loader;
  1382. TestURLLoaderClient client;
  1383. loader_factory->CreateLoaderAndStart(
  1384. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  1385. 0 /* options */, request, client.CreateRemote(),
  1386. net::MutableNetworkTrafficAnnotationTag(
  1387. TRAFFIC_ANNOTATION_FOR_TESTS));
  1388. client.RunUntilComplete();
  1389. EXPECT_TRUE(client.has_received_completion());
  1390. // If validating referrers, and the referrer policy is not to send
  1391. // referrers, the request should fail.
  1392. if (validate_referrer_policy_on_initial_request &&
  1393. referrer_policy == net::ReferrerPolicy::NO_REFERRER) {
  1394. EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT,
  1395. client.completion_status().error_code);
  1396. EXPECT_FALSE(client.response_body().is_valid());
  1397. continue;
  1398. }
  1399. // Otherwise, the request should succeed.
  1400. EXPECT_EQ(net::OK, client.completion_status().error_code);
  1401. std::string response_body;
  1402. ASSERT_TRUE(client.response_body().is_valid());
  1403. EXPECT_TRUE(mojo::BlockingCopyToString(client.response_body_release(),
  1404. &response_body));
  1405. if (referrer_policy == net::ReferrerPolicy::NO_REFERRER) {
  1406. // If not validating referrers, and the referrer policy is not to send
  1407. // referrers, the referrer should be cleared.
  1408. EXPECT_EQ("None", response_body);
  1409. } else {
  1410. // Otherwise, the referrer should be send.
  1411. EXPECT_EQ(kReferrer.spec(), response_body);
  1412. }
  1413. }
  1414. }
  1415. }
  1416. // Validates that clearing the HTTP cache when no cache exists does complete.
  1417. TEST_F(NetworkContextTest, ClearHttpCacheWithNoCache) {
  1418. mojom::NetworkContextParamsPtr context_params =
  1419. CreateNetworkContextParamsForTesting();
  1420. context_params->http_cache_enabled = false;
  1421. std::unique_ptr<NetworkContext> network_context =
  1422. CreateContextWithParams(std::move(context_params));
  1423. net::HttpCache* cache = network_context->url_request_context()
  1424. ->http_transaction_factory()
  1425. ->GetCache();
  1426. ASSERT_EQ(nullptr, cache);
  1427. base::RunLoop run_loop;
  1428. network_context->ClearHttpCache(base::Time(), base::Time(),
  1429. nullptr /* filter */,
  1430. base::BindOnce(run_loop.QuitClosure()));
  1431. run_loop.Run();
  1432. }
  1433. TEST_F(NetworkContextTest, ClearHttpCache) {
  1434. mojom::NetworkContextParamsPtr context_params =
  1435. CreateNetworkContextParamsForTesting();
  1436. context_params->http_cache_enabled = true;
  1437. base::ScopedTempDir temp_dir;
  1438. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  1439. context_params->http_cache_directory = temp_dir.GetPath();
  1440. std::unique_ptr<NetworkContext> network_context =
  1441. CreateContextWithParams(std::move(context_params));
  1442. net::HttpCache* cache = network_context->url_request_context()
  1443. ->http_transaction_factory()
  1444. ->GetCache();
  1445. std::vector<std::string> entry_urls = {
  1446. "http://www.google.com", "https://www.google.com",
  1447. "http://www.wikipedia.com", "https://www.wikipedia.com",
  1448. "http://localhost:1234", "https://localhost:1234",
  1449. };
  1450. ASSERT_TRUE(cache);
  1451. disk_cache::Backend* backend = nullptr;
  1452. net::TestCompletionCallback callback;
  1453. int rv = cache->GetBackend(&backend, callback.callback());
  1454. EXPECT_EQ(net::OK, callback.GetResult(rv));
  1455. ASSERT_TRUE(backend);
  1456. for (const auto& url : entry_urls) {
  1457. disk_cache::EntryResult result;
  1458. base::RunLoop run_loop;
  1459. result = backend->CreateEntry(
  1460. url, net::HIGHEST,
  1461. base::BindLambdaForTesting([&](disk_cache::EntryResult got_result) {
  1462. result = std::move(got_result);
  1463. run_loop.Quit();
  1464. }));
  1465. if (result.net_error() == net::ERR_IO_PENDING)
  1466. run_loop.Run();
  1467. result.ReleaseEntry()->Close();
  1468. }
  1469. EXPECT_EQ(entry_urls.size(), static_cast<size_t>(backend->GetEntryCount()));
  1470. base::RunLoop run_loop;
  1471. network_context->ClearHttpCache(base::Time(), base::Time(),
  1472. nullptr /* filter */,
  1473. base::BindOnce(run_loop.QuitClosure()));
  1474. run_loop.Run();
  1475. EXPECT_EQ(0U, static_cast<size_t>(backend->GetEntryCount()));
  1476. }
  1477. // Checks that when multiple calls are made to clear the HTTP cache, all
  1478. // callbacks are invoked.
  1479. TEST_F(NetworkContextTest, MultipleClearHttpCacheCalls) {
  1480. constexpr int kNumberOfClearCalls = 10;
  1481. mojom::NetworkContextParamsPtr context_params =
  1482. CreateNetworkContextParamsForTesting();
  1483. context_params->http_cache_enabled = true;
  1484. base::ScopedTempDir temp_dir;
  1485. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  1486. context_params->http_cache_directory = temp_dir.GetPath();
  1487. std::unique_ptr<NetworkContext> network_context =
  1488. CreateContextWithParams(std::move(context_params));
  1489. base::RunLoop run_loop;
  1490. base::RepeatingClosure barrier_closure = base::BarrierClosure(
  1491. kNumberOfClearCalls /* num_closures */, run_loop.QuitClosure());
  1492. for (int i = 0; i < kNumberOfClearCalls; i++) {
  1493. network_context->ClearHttpCache(base::Time(), base::Time(),
  1494. nullptr /* filter */,
  1495. base::BindOnce(barrier_closure));
  1496. }
  1497. run_loop.Run();
  1498. // If all the callbacks were invoked, we should terminate.
  1499. }
  1500. TEST_F(NetworkContextTest, NotifyExternalCacheHit) {
  1501. const std::vector<GURL> kUrls = {
  1502. GURL("http://www.google.com/"),
  1503. GURL("http://www.wikipedia.com/"),
  1504. GURL("http://localhost:1234/"),
  1505. };
  1506. const url::Origin kOrigin = url::Origin::Create(GURL("http://a.com"));
  1507. constexpr base::Time kNow1 = base::Time::UnixEpoch() + base::Hours(18);
  1508. constexpr base::Time kNow2 = base::Time::UnixEpoch() + base::Hours(11);
  1509. for (bool enabled : {false, true}) {
  1510. base::test::ScopedFeatureList feature_list;
  1511. if (enabled) {
  1512. feature_list.InitAndEnableFeature(
  1513. net::features::kSplitCacheByNetworkIsolationKey);
  1514. } else {
  1515. feature_list.InitAndDisableFeature(
  1516. net::features::kSplitCacheByNetworkIsolationKey);
  1517. }
  1518. for (const GURL& url : kUrls) {
  1519. for (bool is_subframe_document_resource : {false, true}) {
  1520. mojom::NetworkContextParamsPtr context_params =
  1521. CreateNetworkContextParamsForTesting();
  1522. context_params->http_cache_enabled = true;
  1523. std::unique_ptr<NetworkContext> network_context =
  1524. CreateContextWithParams(std::move(context_params));
  1525. base::SimpleTestClock clock;
  1526. net::HttpCache* cache = network_context->url_request_context()
  1527. ->http_transaction_factory()
  1528. ->GetCache();
  1529. disk_cache::Backend* backend = nullptr;
  1530. // We expect that every cache operation below is done synchronously
  1531. // because we're using an in-memory backend.
  1532. // The disk cache is lazily instantiated, force it and ensure it's
  1533. // valid.
  1534. ASSERT_EQ(cache->GetBackend(&backend, base::BindOnce([](int rv) {})),
  1535. net::OK);
  1536. ASSERT_NE(backend, nullptr);
  1537. static_cast<disk_cache::MemBackendImpl*>(backend)->SetClockForTesting(
  1538. &clock);
  1539. clock.SetNow(kNow1);
  1540. net::NetworkIsolationKey isolation_key(kOrigin, kOrigin);
  1541. net::HttpRequestInfo request_info;
  1542. request_info.url = url;
  1543. request_info.is_subframe_document_resource =
  1544. is_subframe_document_resource;
  1545. request_info.network_isolation_key = isolation_key;
  1546. disk_cache::EntryResult result = backend->OpenOrCreateEntry(
  1547. *net::HttpCache::GenerateCacheKeyForRequest(&request_info),
  1548. net::LOWEST, base::BindOnce([](disk_cache::EntryResult) {}));
  1549. ASSERT_EQ(result.net_error(), net::OK);
  1550. disk_cache::ScopedEntryPtr entry(result.ReleaseEntry());
  1551. EXPECT_EQ(entry->GetLastUsed(), kNow1);
  1552. clock.SetNow(kNow2);
  1553. network_context->NotifyExternalCacheHit(
  1554. url, url.scheme(), isolation_key, is_subframe_document_resource,
  1555. /*include_credentials=*/true);
  1556. EXPECT_EQ(entry->GetLastUsed(), kNow2);
  1557. }
  1558. }
  1559. }
  1560. }
  1561. TEST_F(NetworkContextTest, CountHttpCache) {
  1562. // Just ensure that a couple of concurrent calls go through, and produce
  1563. // the expected "it's empty!" result. More detailed testing is left to
  1564. // HttpCacheDataCounter unit tests.
  1565. mojom::NetworkContextParamsPtr context_params =
  1566. CreateNetworkContextParamsForTesting();
  1567. context_params->http_cache_enabled = true;
  1568. std::unique_ptr<NetworkContext> network_context =
  1569. CreateContextWithParams(std::move(context_params));
  1570. int responses = 0;
  1571. base::RunLoop run_loop;
  1572. auto callback =
  1573. base::BindLambdaForTesting([&](bool upper_bound, int64_t size_or_error) {
  1574. // Don't expect approximation for full range.
  1575. EXPECT_EQ(false, upper_bound);
  1576. EXPECT_EQ(0, size_or_error);
  1577. ++responses;
  1578. if (responses == 2)
  1579. run_loop.Quit();
  1580. });
  1581. network_context->ComputeHttpCacheSize(base::Time(), base::Time::Max(),
  1582. callback);
  1583. network_context->ComputeHttpCacheSize(base::Time(), base::Time::Max(),
  1584. callback);
  1585. run_loop.Run();
  1586. }
  1587. TEST_F(NetworkContextTest, ClearHostCache) {
  1588. // List of domains added to the host cache before running each test case.
  1589. const char* kDomains[] = {
  1590. "domain0",
  1591. "domain1",
  1592. "domain2",
  1593. "domain3",
  1594. };
  1595. // Each bit corresponds to one of the 4 domains above.
  1596. enum Domains {
  1597. NO_DOMAINS = 0x0,
  1598. DOMAIN0 = 0x1,
  1599. DOMAIN1 = 0x2,
  1600. DOMAIN2 = 0x4,
  1601. DOMAIN3 = 0x8,
  1602. };
  1603. const struct {
  1604. // True if the ClearDataFilter should be a nullptr.
  1605. bool null_filter;
  1606. mojom::ClearDataFilter::Type type;
  1607. // Bit field of Domains that appear in the filter. The origin vector is
  1608. // never populated.
  1609. int filter_domains;
  1610. // Only domains that are expected to remain in the host cache.
  1611. int expected_cached_domains;
  1612. } kTestCases[] = {
  1613. // A null filter should delete everything. The filter type and filter
  1614. // domain lists are ignored.
  1615. {
  1616. true /* null_filter */, mojom::ClearDataFilter::Type::KEEP_MATCHES,
  1617. NO_DOMAINS /* filter_domains */,
  1618. NO_DOMAINS /* expected_cached_domains */
  1619. },
  1620. // An empty DELETE_MATCHES filter should delete nothing.
  1621. {
  1622. false /* null_filter */, mojom::ClearDataFilter::Type::DELETE_MATCHES,
  1623. NO_DOMAINS /* filter_domains */,
  1624. DOMAIN0 | DOMAIN1 | DOMAIN2 | DOMAIN3 /* expected_cached_domains */
  1625. },
  1626. // An empty KEEP_MATCHES filter should delete everything.
  1627. {
  1628. false /* null_filter */, mojom::ClearDataFilter::Type::KEEP_MATCHES,
  1629. NO_DOMAINS /* filter_domains */,
  1630. NO_DOMAINS /* expected_cached_domains */
  1631. },
  1632. // Test a non-empty DELETE_MATCHES filter.
  1633. {
  1634. false /* null_filter */, mojom::ClearDataFilter::Type::DELETE_MATCHES,
  1635. DOMAIN0 | DOMAIN2 /* filter_domains */,
  1636. DOMAIN1 | DOMAIN3 /* expected_cached_domains */
  1637. },
  1638. // Test a non-empty KEEP_MATCHES filter.
  1639. {
  1640. false /* null_filter */, mojom::ClearDataFilter::Type::KEEP_MATCHES,
  1641. DOMAIN0 | DOMAIN2 /* filter_domains */,
  1642. DOMAIN0 | DOMAIN2 /* expected_cached_domains */
  1643. },
  1644. };
  1645. for (const auto& test_case : kTestCases) {
  1646. std::unique_ptr<NetworkContext> network_context =
  1647. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1648. net::HostCache* host_cache =
  1649. network_context->url_request_context()->host_resolver()->GetHostCache();
  1650. ASSERT_TRUE(host_cache);
  1651. // Add the 4 test domains to the host cache, each once with scheme and once
  1652. // without.
  1653. for (const auto* domain : kDomains) {
  1654. host_cache->Set(
  1655. net::HostCache::Key(domain, net::DnsQueryType::UNSPECIFIED, 0,
  1656. net::HostResolverSource::ANY,
  1657. net::NetworkIsolationKey()),
  1658. net::HostCache::Entry(net::OK, /*ip_endpoints=*/{}, /*aliases=*/{},
  1659. net::HostCache::Entry::SOURCE_UNKNOWN),
  1660. base::TimeTicks::Now(), base::Days(1));
  1661. host_cache->Set(
  1662. net::HostCache::Key(
  1663. url::SchemeHostPort(url::kHttpsScheme, domain, 443),
  1664. net::DnsQueryType::UNSPECIFIED, 0, net::HostResolverSource::ANY,
  1665. net::NetworkIsolationKey()),
  1666. net::HostCache::Entry(net::OK, /*ip_endpoints=*/{}, /*aliases=*/{},
  1667. net::HostCache::Entry::SOURCE_UNKNOWN),
  1668. base::TimeTicks::Now(), base::Days(1));
  1669. }
  1670. // Sanity check.
  1671. EXPECT_EQ(std::size(kDomains) * 2, host_cache->entries().size());
  1672. // Set up and run the filter, according to |test_case|.
  1673. mojom::ClearDataFilterPtr clear_data_filter;
  1674. if (!test_case.null_filter) {
  1675. clear_data_filter = mojom::ClearDataFilter::New();
  1676. clear_data_filter->type = test_case.type;
  1677. for (size_t i = 0; i < std::size(kDomains); ++i) {
  1678. if (test_case.filter_domains & (1 << i))
  1679. clear_data_filter->domains.push_back(kDomains[i]);
  1680. }
  1681. }
  1682. base::RunLoop run_loop;
  1683. network_context->ClearHostCache(std::move(clear_data_filter),
  1684. run_loop.QuitClosure());
  1685. run_loop.Run();
  1686. // Check that only the expected domains remain in the cache.
  1687. size_t expected_cached = 0;
  1688. for (size_t i = 0; i < std::size(kDomains); ++i) {
  1689. bool expect_domain_cached =
  1690. ((test_case.expected_cached_domains & (1 << i)) != 0);
  1691. EXPECT_EQ(expect_domain_cached,
  1692. (host_cache->GetMatchingKeyForTesting(
  1693. kDomains[i], nullptr /* source_out */,
  1694. nullptr /* stale_out */) != nullptr));
  1695. if (expect_domain_cached)
  1696. expected_cached += 2;
  1697. }
  1698. EXPECT_EQ(host_cache->entries().size(), expected_cached);
  1699. }
  1700. }
  1701. TEST_F(NetworkContextTest, ClearHttpAuthCache) {
  1702. url::SchemeHostPort scheme_host_port(GURL("http://google.com"));
  1703. std::unique_ptr<NetworkContext> network_context =
  1704. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1705. net::HttpAuthCache* cache = network_context->url_request_context()
  1706. ->http_transaction_factory()
  1707. ->GetSession()
  1708. ->http_auth_cache();
  1709. base::Time start_time;
  1710. ASSERT_TRUE(base::Time::FromString("30 May 2018 12:00:00", &start_time));
  1711. base::SimpleTestClock test_clock;
  1712. test_clock.SetNow(start_time);
  1713. cache->set_clock_for_testing(&test_clock);
  1714. std::u16string user = u"user";
  1715. std::u16string password = u"pass";
  1716. cache->Add(scheme_host_port, net::HttpAuth::AUTH_SERVER, "Realm1",
  1717. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey(),
  1718. "basic realm=Realm1", net::AuthCredentials(user, password), "/");
  1719. test_clock.Advance(base::Hours(1)); // Time now 13:00
  1720. cache->Add(scheme_host_port, net::HttpAuth::AUTH_PROXY, "Realm2",
  1721. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey(),
  1722. "basic realm=Realm2", net::AuthCredentials(user, password), "/");
  1723. ASSERT_EQ(2u, cache->GetEntriesSizeForTesting());
  1724. ASSERT_NE(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  1725. "Realm1", net::HttpAuth::AUTH_SCHEME_BASIC,
  1726. net::NetworkIsolationKey()));
  1727. ASSERT_NE(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  1728. "Realm2", net::HttpAuth::AUTH_SCHEME_BASIC,
  1729. net::NetworkIsolationKey()));
  1730. {
  1731. base::RunLoop run_loop;
  1732. base::Time test_time;
  1733. ASSERT_TRUE(base::Time::FromString("30 May 2018 12:30:00", &test_time));
  1734. network_context->ClearHttpAuthCache(base::Time(), test_time,
  1735. run_loop.QuitClosure());
  1736. run_loop.Run();
  1737. EXPECT_EQ(1u, cache->GetEntriesSizeForTesting());
  1738. EXPECT_EQ(nullptr,
  1739. cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  1740. "Realm1", net::HttpAuth::AUTH_SCHEME_BASIC,
  1741. net::NetworkIsolationKey()));
  1742. EXPECT_NE(nullptr,
  1743. cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  1744. "Realm2", net::HttpAuth::AUTH_SCHEME_BASIC,
  1745. net::NetworkIsolationKey()));
  1746. }
  1747. {
  1748. base::RunLoop run_loop;
  1749. base::Time test_time;
  1750. ASSERT_TRUE(base::Time::FromString("30 May 2018 12:30:00", &test_time));
  1751. network_context->ClearHttpAuthCache(test_time, base::Time::Max(),
  1752. run_loop.QuitClosure());
  1753. run_loop.Run();
  1754. EXPECT_EQ(0u, cache->GetEntriesSizeForTesting());
  1755. EXPECT_EQ(nullptr,
  1756. cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  1757. "Realm1", net::HttpAuth::AUTH_SCHEME_BASIC,
  1758. net::NetworkIsolationKey()));
  1759. EXPECT_EQ(nullptr,
  1760. cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  1761. "Realm2", net::HttpAuth::AUTH_SCHEME_BASIC,
  1762. net::NetworkIsolationKey()));
  1763. }
  1764. }
  1765. TEST_F(NetworkContextTest, ClearAllHttpAuthCache) {
  1766. url::SchemeHostPort scheme_host_port(GURL("http://google.com"));
  1767. std::unique_ptr<NetworkContext> network_context =
  1768. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1769. net::HttpAuthCache* cache = network_context->url_request_context()
  1770. ->http_transaction_factory()
  1771. ->GetSession()
  1772. ->http_auth_cache();
  1773. base::Time start_time;
  1774. ASSERT_TRUE(base::Time::FromString("30 May 2018 12:00:00", &start_time));
  1775. base::SimpleTestClock test_clock;
  1776. test_clock.SetNow(start_time);
  1777. cache->set_clock_for_testing(&test_clock);
  1778. std::u16string user = u"user";
  1779. std::u16string password = u"pass";
  1780. cache->Add(scheme_host_port, net::HttpAuth::AUTH_SERVER, "Realm1",
  1781. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey(),
  1782. "basic realm=Realm1", net::AuthCredentials(user, password), "/");
  1783. test_clock.Advance(base::Hours(1)); // Time now 13:00
  1784. cache->Add(scheme_host_port, net::HttpAuth::AUTH_PROXY, "Realm2",
  1785. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey(),
  1786. "basic realm=Realm2", net::AuthCredentials(user, password), "/");
  1787. ASSERT_EQ(2u, cache->GetEntriesSizeForTesting());
  1788. ASSERT_NE(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  1789. "Realm1", net::HttpAuth::AUTH_SCHEME_BASIC,
  1790. net::NetworkIsolationKey()));
  1791. ASSERT_NE(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  1792. "Realm2", net::HttpAuth::AUTH_SCHEME_BASIC,
  1793. net::NetworkIsolationKey()));
  1794. base::RunLoop run_loop;
  1795. network_context->ClearHttpAuthCache(base::Time(), base::Time::Max(),
  1796. run_loop.QuitClosure());
  1797. run_loop.Run();
  1798. EXPECT_EQ(0u, cache->GetEntriesSizeForTesting());
  1799. EXPECT_EQ(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  1800. "Realm1", net::HttpAuth::AUTH_SCHEME_BASIC,
  1801. net::NetworkIsolationKey()));
  1802. EXPECT_EQ(nullptr, cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  1803. "Realm2", net::HttpAuth::AUTH_SCHEME_BASIC,
  1804. net::NetworkIsolationKey()));
  1805. }
  1806. TEST_F(NetworkContextTest, ClearEmptyHttpAuthCache) {
  1807. std::unique_ptr<NetworkContext> network_context =
  1808. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1809. net::HttpAuthCache* cache = network_context->url_request_context()
  1810. ->http_transaction_factory()
  1811. ->GetSession()
  1812. ->http_auth_cache();
  1813. ASSERT_EQ(0u, cache->GetEntriesSizeForTesting());
  1814. base::RunLoop run_loop;
  1815. network_context->ClearHttpAuthCache(base::Time::UnixEpoch(),
  1816. base::Time::Max(),
  1817. base::BindOnce(run_loop.QuitClosure()));
  1818. run_loop.Run();
  1819. EXPECT_EQ(0u, cache->GetEntriesSizeForTesting());
  1820. }
  1821. absl::optional<net::AuthCredentials> GetAuthCredentials(
  1822. NetworkContext* network_context,
  1823. const GURL& origin,
  1824. const net::NetworkIsolationKey& network_isolation_key) {
  1825. base::RunLoop run_loop;
  1826. absl::optional<net::AuthCredentials> result;
  1827. network_context->LookupServerBasicAuthCredentials(
  1828. origin, network_isolation_key,
  1829. base::BindLambdaForTesting(
  1830. [&](const absl::optional<net::AuthCredentials>& credentials) {
  1831. result = credentials;
  1832. run_loop.Quit();
  1833. }));
  1834. run_loop.Run();
  1835. return result;
  1836. }
  1837. TEST_F(NetworkContextTest, LookupServerBasicAuthCredentials) {
  1838. GURL origin("http://foo.test");
  1839. GURL origin2("http://bar.test");
  1840. GURL origin3("http://baz.test");
  1841. net::NetworkIsolationKey network_isolation_key1(url::Origin::Create(origin),
  1842. url::Origin::Create(origin));
  1843. net::NetworkIsolationKey network_isolation_key2(url::Origin::Create(origin2),
  1844. url::Origin::Create(origin2));
  1845. std::unique_ptr<NetworkContext> network_context =
  1846. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1847. network_context->SetSplitAuthCacheByNetworkIsolationKey(true);
  1848. net::HttpAuthCache* cache = network_context->url_request_context()
  1849. ->http_transaction_factory()
  1850. ->GetSession()
  1851. ->http_auth_cache();
  1852. std::u16string user = u"user";
  1853. std::u16string password = u"pass";
  1854. cache->Add(url::SchemeHostPort(origin), net::HttpAuth::AUTH_SERVER, "Realm",
  1855. net::HttpAuth::AUTH_SCHEME_BASIC, network_isolation_key1,
  1856. "basic realm=Realm", net::AuthCredentials(user, password), "/");
  1857. cache->Add(url::SchemeHostPort(origin2), net::HttpAuth::AUTH_PROXY, "Realm",
  1858. net::HttpAuth::AUTH_SCHEME_BASIC, network_isolation_key1,
  1859. "basic realm=Realm", net::AuthCredentials(user, password), "/");
  1860. absl::optional<net::AuthCredentials> result =
  1861. GetAuthCredentials(network_context.get(), origin, network_isolation_key1);
  1862. ASSERT_TRUE(result.has_value());
  1863. EXPECT_EQ(user, result->username());
  1864. EXPECT_EQ(password, result->password());
  1865. // Nothing should be returned when using a different NIK.
  1866. EXPECT_FALSE(
  1867. GetAuthCredentials(network_context.get(), origin, network_isolation_key2)
  1868. .has_value());
  1869. // Proxy credentials should not be returned
  1870. result = GetAuthCredentials(network_context.get(), origin2,
  1871. network_isolation_key1);
  1872. EXPECT_FALSE(result.has_value());
  1873. }
  1874. #if BUILDFLAG(IS_CHROMEOS_ASH)
  1875. absl::optional<net::AuthCredentials> GetProxyAuthCredentials(
  1876. NetworkContext* network_context,
  1877. const net::ProxyServer& proxy_server,
  1878. const std::string& scheme,
  1879. const std::string& realm) {
  1880. base::RunLoop run_loop;
  1881. absl::optional<net::AuthCredentials> result;
  1882. network_context->LookupProxyAuthCredentials(
  1883. proxy_server, scheme, realm,
  1884. base::BindLambdaForTesting(
  1885. [&](const absl::optional<net::AuthCredentials>& credentials) {
  1886. result = credentials;
  1887. run_loop.Quit();
  1888. }));
  1889. run_loop.Run();
  1890. return result;
  1891. }
  1892. TEST_F(NetworkContextTest, LookupProxyAuthCredentials) {
  1893. GURL http_proxy("http://bar.test:1080");
  1894. GURL https_proxy("https://bar.test:443");
  1895. GURL http_proxy2("http://bar.test:443");
  1896. GURL foo_proxy("foo://bar.test:1080");
  1897. GURL server_origin("http://foo.test:3128");
  1898. std::unique_ptr<NetworkContext> network_context =
  1899. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  1900. network_context->SetSplitAuthCacheByNetworkIsolationKey(true);
  1901. net::HttpAuthCache* cache = network_context->url_request_context()
  1902. ->http_transaction_factory()
  1903. ->GetSession()
  1904. ->http_auth_cache();
  1905. std::u16string user = u"user";
  1906. std::u16string password = u"pass";
  1907. cache->Add(url::SchemeHostPort(http_proxy), net::HttpAuth::AUTH_PROXY,
  1908. "Realm", net::HttpAuth::AUTH_SCHEME_BASIC,
  1909. net::NetworkIsolationKey(), "basic realm=Realm",
  1910. net::AuthCredentials(user, password),
  1911. /* path = */ "");
  1912. cache->Add(url::SchemeHostPort(https_proxy), net::HttpAuth::AUTH_PROXY,
  1913. "Realm", net::HttpAuth::AUTH_SCHEME_BASIC,
  1914. net::NetworkIsolationKey(), "basic realm=Realm",
  1915. net::AuthCredentials(user, password),
  1916. /* path = */ "");
  1917. cache->Add(url::SchemeHostPort(server_origin), net::HttpAuth::AUTH_SERVER,
  1918. "Realm", net::HttpAuth::AUTH_SCHEME_BASIC,
  1919. net::NetworkIsolationKey(), "basic realm=Realm",
  1920. net::AuthCredentials(user, password),
  1921. /* path = */ "/");
  1922. absl::optional<net::AuthCredentials> result = GetProxyAuthCredentials(
  1923. network_context.get(),
  1924. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1925. net::HostPortPair::FromURL(http_proxy)),
  1926. "bAsIc", "Realm");
  1927. ASSERT_TRUE(result.has_value());
  1928. EXPECT_EQ(user, result->username());
  1929. EXPECT_EQ(password, result->password());
  1930. result = GetProxyAuthCredentials(
  1931. network_context.get(),
  1932. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTPS,
  1933. net::HostPortPair::FromURL(https_proxy)),
  1934. "bAsIc", "Realm");
  1935. ASSERT_TRUE(result.has_value());
  1936. EXPECT_EQ(user, result->username());
  1937. EXPECT_EQ(password, result->password());
  1938. // Check that the proxy scheme is taken into account when looking for
  1939. // credentials
  1940. result = GetProxyAuthCredentials(
  1941. network_context.get(),
  1942. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1943. net::HostPortPair::FromURL(http_proxy2)),
  1944. "basic", "Realm");
  1945. EXPECT_FALSE(result.has_value());
  1946. // Check that the proxy authentication method is taken into account when
  1947. // looking for credentials
  1948. result = GetProxyAuthCredentials(
  1949. network_context.get(),
  1950. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1951. net::HostPortPair::FromURL(http_proxy)),
  1952. "digest", "Realm");
  1953. EXPECT_FALSE(result.has_value());
  1954. // Check that the realm is taken into account when looking for credentials
  1955. result = GetProxyAuthCredentials(
  1956. network_context.get(),
  1957. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1958. net::HostPortPair::FromURL(http_proxy)),
  1959. "basic", "Realm 2");
  1960. EXPECT_FALSE(result.has_value());
  1961. // All non-https proxies are cached as "http://" proxies
  1962. result = GetProxyAuthCredentials(
  1963. network_context.get(),
  1964. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1965. net::HostPortPair::FromURL(foo_proxy)),
  1966. "basic", "Realm");
  1967. EXPECT_FALSE(result.has_value());
  1968. // Server credentials should not be returned
  1969. result = GetProxyAuthCredentials(
  1970. network_context.get(),
  1971. net::ProxyServer(net::ProxyServer::Scheme::SCHEME_HTTP,
  1972. net::HostPortPair::FromURL(server_origin)),
  1973. "basic", "Realm");
  1974. EXPECT_FALSE(result.has_value());
  1975. }
  1976. #endif
  1977. #if BUILDFLAG(ENABLE_REPORTING)
  1978. TEST_F(NetworkContextTest, ClearReportingCacheReports) {
  1979. auto reporting_context = std::make_unique<net::TestReportingContext>(
  1980. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  1981. net::ReportingPolicy());
  1982. net::ReportingCache* reporting_cache = reporting_context->cache();
  1983. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  1984. CreateNetworkContextParamsForTesting(),
  1985. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  1986. GURL domain("http://google.com");
  1987. network_context->url_request_context()->reporting_service()->QueueReport(
  1988. domain, absl::nullopt, net::NetworkIsolationKey(), "Mozilla/1.0", "group",
  1989. "type", base::Value::Dict(), 0);
  1990. std::vector<const net::ReportingReport*> reports;
  1991. reporting_cache->GetReports(&reports);
  1992. ASSERT_EQ(1u, reports.size());
  1993. base::RunLoop run_loop;
  1994. network_context->ClearReportingCacheReports(nullptr /* filter */,
  1995. run_loop.QuitClosure());
  1996. run_loop.Run();
  1997. reporting_cache->GetReports(&reports);
  1998. EXPECT_EQ(0u, reports.size());
  1999. }
  2000. TEST_F(NetworkContextTest, ClearReportingCacheReportsWithFilter) {
  2001. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2002. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2003. net::ReportingPolicy());
  2004. net::ReportingCache* reporting_cache = reporting_context->cache();
  2005. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2006. CreateNetworkContextParamsForTesting(),
  2007. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2008. net::ReportingService* reporting_service =
  2009. network_context->url_request_context()->reporting_service();
  2010. GURL url1("http://google.com");
  2011. reporting_service->QueueReport(url1, absl::nullopt,
  2012. net::NetworkIsolationKey(), "Mozilla/1.0",
  2013. "group", "type", base::Value::Dict(), 0);
  2014. GURL url2("http://chromium.org");
  2015. reporting_service->QueueReport(url2, absl::nullopt,
  2016. net::NetworkIsolationKey(), "Mozilla/1.0",
  2017. "group", "type", base::Value::Dict(), 0);
  2018. std::vector<const net::ReportingReport*> reports;
  2019. reporting_cache->GetReports(&reports);
  2020. ASSERT_EQ(2u, reports.size());
  2021. mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
  2022. filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
  2023. filter->domains.push_back("chromium.org");
  2024. base::RunLoop run_loop;
  2025. network_context->ClearReportingCacheReports(std::move(filter),
  2026. run_loop.QuitClosure());
  2027. run_loop.Run();
  2028. reporting_cache->GetReports(&reports);
  2029. EXPECT_EQ(1u, reports.size());
  2030. EXPECT_EQ(url2, reports.front()->url);
  2031. }
  2032. TEST_F(NetworkContextTest,
  2033. ClearReportingCacheReportsWithNonRegisterableFilter) {
  2034. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2035. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2036. net::ReportingPolicy());
  2037. net::ReportingCache* reporting_cache = reporting_context->cache();
  2038. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2039. CreateNetworkContextParamsForTesting(),
  2040. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2041. net::ReportingService* reporting_service =
  2042. network_context->url_request_context()->reporting_service();
  2043. GURL url1("http://192.168.0.1");
  2044. reporting_service->QueueReport(url1, absl::nullopt,
  2045. net::NetworkIsolationKey(), "Mozilla/1.0",
  2046. "group", "type", base::Value::Dict(), 0);
  2047. GURL url2("http://192.168.0.2");
  2048. reporting_service->QueueReport(url2, absl::nullopt,
  2049. net::NetworkIsolationKey(), "Mozilla/1.0",
  2050. "group", "type", base::Value::Dict(), 0);
  2051. std::vector<const net::ReportingReport*> reports;
  2052. reporting_cache->GetReports(&reports);
  2053. ASSERT_EQ(2u, reports.size());
  2054. mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
  2055. filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
  2056. filter->domains.push_back("192.168.0.2");
  2057. base::RunLoop run_loop;
  2058. network_context->ClearReportingCacheReports(std::move(filter),
  2059. run_loop.QuitClosure());
  2060. run_loop.Run();
  2061. reporting_cache->GetReports(&reports);
  2062. EXPECT_EQ(1u, reports.size());
  2063. EXPECT_EQ(url2, reports.front()->url);
  2064. }
  2065. TEST_F(NetworkContextTest, ClearEmptyReportingCacheReports) {
  2066. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2067. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2068. net::ReportingPolicy());
  2069. net::ReportingCache* reporting_cache = reporting_context->cache();
  2070. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2071. CreateNetworkContextParamsForTesting(),
  2072. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2073. std::vector<const net::ReportingReport*> reports;
  2074. reporting_cache->GetReports(&reports);
  2075. ASSERT_TRUE(reports.empty());
  2076. base::RunLoop run_loop;
  2077. network_context->ClearReportingCacheReports(nullptr /* filter */,
  2078. run_loop.QuitClosure());
  2079. run_loop.Run();
  2080. reporting_cache->GetReports(&reports);
  2081. EXPECT_TRUE(reports.empty());
  2082. }
  2083. TEST_F(NetworkContextTest, ClearReportingCacheReportsWithNoService) {
  2084. base::test::ScopedFeatureList scoped_feature_list_;
  2085. scoped_feature_list_.InitAndDisableFeature(features::kReporting);
  2086. std::unique_ptr<NetworkContext> network_context =
  2087. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2088. ASSERT_EQ(nullptr,
  2089. network_context->url_request_context()->reporting_service());
  2090. base::RunLoop run_loop;
  2091. network_context->ClearReportingCacheReports(nullptr /* filter */,
  2092. run_loop.QuitClosure());
  2093. run_loop.Run();
  2094. }
  2095. TEST_F(NetworkContextTest, ClearReportingCacheClients) {
  2096. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2097. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2098. net::ReportingPolicy());
  2099. net::ReportingCache* reporting_cache = reporting_context->cache();
  2100. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2101. CreateNetworkContextParamsForTesting(),
  2102. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2103. GURL domain("https://google.com");
  2104. net::ReportingEndpointGroupKey group_key(
  2105. net::NetworkIsolationKey(), url::Origin::Create(domain), "group");
  2106. reporting_cache->SetEndpointForTesting(
  2107. group_key, domain, net::OriginSubdomains::DEFAULT, base::Time::Max(),
  2108. 1 /* priority */, 1 /* weight */);
  2109. ASSERT_EQ(1u, reporting_cache->GetEndpointCount());
  2110. base::RunLoop run_loop;
  2111. network_context->ClearReportingCacheClients(nullptr /* filter */,
  2112. run_loop.QuitClosure());
  2113. run_loop.Run();
  2114. EXPECT_EQ(0u, reporting_cache->GetEndpointCount());
  2115. }
  2116. TEST_F(NetworkContextTest, ClearReportingCacheClientsWithFilter) {
  2117. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2118. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2119. net::ReportingPolicy());
  2120. net::ReportingCache* reporting_cache = reporting_context->cache();
  2121. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2122. CreateNetworkContextParamsForTesting(),
  2123. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2124. GURL domain1("https://google.com");
  2125. net::ReportingEndpointGroupKey group_key1(
  2126. net::NetworkIsolationKey(), url::Origin::Create(domain1), "group");
  2127. reporting_cache->SetEndpointForTesting(
  2128. group_key1, domain1, net::OriginSubdomains::DEFAULT, base::Time::Max(),
  2129. 1 /* priority */, 1 /* weight */);
  2130. GURL domain2("https://chromium.org");
  2131. net::ReportingEndpointGroupKey group_key2(
  2132. net::NetworkIsolationKey(), url::Origin::Create(domain2), "group");
  2133. reporting_cache->SetEndpointForTesting(
  2134. group_key2, domain2, net::OriginSubdomains::DEFAULT, base::Time::Max(),
  2135. 1 /* priority */, 1 /* weight */);
  2136. ASSERT_EQ(2u, reporting_cache->GetEndpointCount());
  2137. mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
  2138. filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
  2139. filter->domains.push_back("chromium.org");
  2140. base::RunLoop run_loop;
  2141. network_context->ClearReportingCacheClients(std::move(filter),
  2142. run_loop.QuitClosure());
  2143. run_loop.Run();
  2144. EXPECT_EQ(1u, reporting_cache->GetEndpointCount());
  2145. EXPECT_TRUE(reporting_cache->GetEndpointForTesting(group_key2, domain2));
  2146. EXPECT_FALSE(reporting_cache->GetEndpointForTesting(group_key1, domain1));
  2147. }
  2148. TEST_F(NetworkContextTest, ClearEmptyReportingCacheClients) {
  2149. auto reporting_context = std::make_unique<net::TestReportingContext>(
  2150. base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
  2151. net::ReportingPolicy());
  2152. net::ReportingCache* reporting_cache = reporting_context->cache();
  2153. std::unique_ptr<NetworkContext> network_context = CreateContextWithParams(
  2154. CreateNetworkContextParamsForTesting(),
  2155. net::ReportingService::CreateForTesting(std::move(reporting_context)));
  2156. ASSERT_EQ(0u, reporting_cache->GetEndpointCount());
  2157. base::RunLoop run_loop;
  2158. network_context->ClearReportingCacheClients(nullptr /* filter */,
  2159. run_loop.QuitClosure());
  2160. run_loop.Run();
  2161. ASSERT_EQ(0u, reporting_cache->GetEndpointCount());
  2162. }
  2163. TEST_F(NetworkContextTest, ClearReportingCacheClientsWithNoService) {
  2164. base::test::ScopedFeatureList scoped_feature_list_;
  2165. scoped_feature_list_.InitAndDisableFeature(features::kReporting);
  2166. std::unique_ptr<NetworkContext> network_context =
  2167. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2168. ASSERT_EQ(nullptr,
  2169. network_context->url_request_context()->reporting_service());
  2170. base::RunLoop run_loop;
  2171. network_context->ClearReportingCacheClients(nullptr /* filter */,
  2172. run_loop.QuitClosure());
  2173. run_loop.Run();
  2174. }
  2175. TEST_F(NetworkContextTest, ClearNetworkErrorLogging) {
  2176. base::test::ScopedFeatureList scoped_feature_list_;
  2177. scoped_feature_list_.InitAndEnableFeature(features::kNetworkErrorLogging);
  2178. std::unique_ptr<NetworkContext> network_context =
  2179. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2180. net::NetworkErrorLoggingService* logging_service =
  2181. network_context->url_request_context()->network_error_logging_service();
  2182. ASSERT_TRUE(logging_service);
  2183. GURL domain("https://google.com");
  2184. logging_service->OnHeader(net::NetworkIsolationKey(),
  2185. url::Origin::Create(domain),
  2186. net::IPAddress(192, 168, 0, 1),
  2187. "{\"report_to\":\"group\",\"max_age\":86400}");
  2188. ASSERT_EQ(1u, logging_service->GetPolicyKeysForTesting().size());
  2189. base::RunLoop run_loop;
  2190. network_context->ClearNetworkErrorLogging(nullptr /* filter */,
  2191. run_loop.QuitClosure());
  2192. run_loop.Run();
  2193. EXPECT_TRUE(logging_service->GetPolicyKeysForTesting().empty());
  2194. }
  2195. TEST_F(NetworkContextTest, ClearNetworkErrorLoggingWithFilter) {
  2196. base::test::ScopedFeatureList scoped_feature_list_;
  2197. scoped_feature_list_.InitAndEnableFeature(features::kNetworkErrorLogging);
  2198. std::unique_ptr<NetworkContext> network_context =
  2199. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2200. net::NetworkErrorLoggingService* logging_service =
  2201. network_context->url_request_context()->network_error_logging_service();
  2202. ASSERT_TRUE(logging_service);
  2203. GURL domain1("https://google.com");
  2204. logging_service->OnHeader(net::NetworkIsolationKey(),
  2205. url::Origin::Create(domain1),
  2206. net::IPAddress(192, 168, 0, 1),
  2207. "{\"report_to\":\"group\",\"max_age\":86400}");
  2208. GURL domain2("https://chromium.org");
  2209. logging_service->OnHeader(net::NetworkIsolationKey(),
  2210. url::Origin::Create(domain2),
  2211. net::IPAddress(192, 168, 0, 1),
  2212. "{\"report_to\":\"group\",\"max_age\":86400}");
  2213. ASSERT_EQ(2u, logging_service->GetPolicyKeysForTesting().size());
  2214. mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
  2215. filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
  2216. filter->domains.push_back("chromium.org");
  2217. base::RunLoop run_loop;
  2218. network_context->ClearNetworkErrorLogging(std::move(filter),
  2219. run_loop.QuitClosure());
  2220. run_loop.Run();
  2221. std::set<net::NetworkErrorLoggingService::NelPolicyKey> policy_keys =
  2222. logging_service->GetPolicyKeysForTesting();
  2223. EXPECT_EQ(1u, policy_keys.size());
  2224. EXPECT_THAT(
  2225. policy_keys,
  2226. testing::ElementsAre(net::NetworkErrorLoggingService::NelPolicyKey(
  2227. net::NetworkIsolationKey(), url::Origin::Create(domain2))));
  2228. }
  2229. TEST_F(NetworkContextTest, ClearEmptyNetworkErrorLogging) {
  2230. base::test::ScopedFeatureList scoped_feature_list_;
  2231. scoped_feature_list_.InitAndEnableFeature(features::kNetworkErrorLogging);
  2232. std::unique_ptr<NetworkContext> network_context =
  2233. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2234. net::NetworkErrorLoggingService* logging_service =
  2235. network_context->url_request_context()->network_error_logging_service();
  2236. ASSERT_TRUE(logging_service);
  2237. ASSERT_TRUE(logging_service->GetPolicyKeysForTesting().empty());
  2238. base::RunLoop run_loop;
  2239. network_context->ClearNetworkErrorLogging(nullptr /* filter */,
  2240. run_loop.QuitClosure());
  2241. run_loop.Run();
  2242. EXPECT_TRUE(logging_service->GetPolicyKeysForTesting().empty());
  2243. }
  2244. TEST_F(NetworkContextTest, ClearEmptyNetworkErrorLoggingWithNoService) {
  2245. base::test::ScopedFeatureList scoped_feature_list_;
  2246. scoped_feature_list_.InitAndDisableFeature(features::kNetworkErrorLogging);
  2247. std::unique_ptr<NetworkContext> network_context =
  2248. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2249. ASSERT_FALSE(
  2250. network_context->url_request_context()->network_error_logging_service());
  2251. base::RunLoop run_loop;
  2252. network_context->ClearNetworkErrorLogging(nullptr /* filter */,
  2253. run_loop.QuitClosure());
  2254. run_loop.Run();
  2255. }
  2256. #endif // BUILDFLAG(ENABLE_REPORTING)
  2257. void SetCookieCallback(base::RunLoop* run_loop,
  2258. bool* result_out,
  2259. net::CookieAccessResult result) {
  2260. *result_out = result.status.IsInclude();
  2261. run_loop->Quit();
  2262. }
  2263. void GetCookieListCallback(
  2264. base::RunLoop* run_loop,
  2265. net::CookieList* result_out,
  2266. const net::CookieAccessResultList& result,
  2267. const net::CookieAccessResultList& excluded_cookies) {
  2268. *result_out = net::cookie_util::StripAccessResults(result);
  2269. run_loop->Quit();
  2270. }
  2271. bool SetCookieHelper(NetworkContext* network_context,
  2272. const GURL& url,
  2273. const std::string& key,
  2274. const std::string& value) {
  2275. mojo::Remote<mojom::CookieManager> cookie_manager;
  2276. network_context->GetCookieManager(
  2277. cookie_manager.BindNewPipeAndPassReceiver());
  2278. base::RunLoop run_loop;
  2279. bool result = false;
  2280. cookie_manager->SetCanonicalCookie(
  2281. *net::CanonicalCookie::CreateUnsafeCookieForTesting(
  2282. key, value, url.host(), "/", base::Time(), base::Time(), base::Time(),
  2283. base::Time(), true, false, net::CookieSameSite::NO_RESTRICTION,
  2284. net::COOKIE_PRIORITY_LOW, false),
  2285. url, net::CookieOptions::MakeAllInclusive(),
  2286. base::BindOnce(&SetCookieCallback, &run_loop, &result));
  2287. run_loop.Run();
  2288. return result;
  2289. }
  2290. TEST_F(NetworkContextTest, CookieManager) {
  2291. std::unique_ptr<NetworkContext> network_context =
  2292. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2293. mojo::Remote<mojom::CookieManager> cookie_manager_remote;
  2294. network_context->GetCookieManager(
  2295. cookie_manager_remote.BindNewPipeAndPassReceiver());
  2296. // Set a cookie through the cookie interface.
  2297. base::RunLoop run_loop1;
  2298. bool result = false;
  2299. auto cookie = net::CanonicalCookie::CreateUnsafeCookieForTesting(
  2300. "TestCookie", "1", "www.test.com", "/", base::Time(), base::Time(),
  2301. base::Time(), base::Time(), false, false, net::CookieSameSite::LAX_MODE,
  2302. net::COOKIE_PRIORITY_LOW, false);
  2303. cookie_manager_remote->SetCanonicalCookie(
  2304. *cookie, net::cookie_util::SimulatedCookieSource(*cookie, "https"),
  2305. net::CookieOptions::MakeAllInclusive(),
  2306. base::BindOnce(&SetCookieCallback, &run_loop1, &result));
  2307. run_loop1.Run();
  2308. EXPECT_TRUE(result);
  2309. // Confirm that cookie is visible directly through the store associated with
  2310. // the network context.
  2311. base::RunLoop run_loop2;
  2312. net::CookieList cookies;
  2313. network_context->url_request_context()
  2314. ->cookie_store()
  2315. ->GetCookieListWithOptionsAsync(
  2316. GURL("http://www.test.com/whatever"),
  2317. net::CookieOptions::MakeAllInclusive(),
  2318. net::CookiePartitionKeyCollection(),
  2319. base::BindOnce(&GetCookieListCallback, &run_loop2, &cookies));
  2320. run_loop2.Run();
  2321. ASSERT_EQ(1u, cookies.size());
  2322. EXPECT_EQ("TestCookie", cookies[0].Name());
  2323. }
  2324. TEST_F(NetworkContextTest, ProxyConfig) {
  2325. // Each ProxyConfigSet consists of a net::ProxyConfig, and the net::ProxyInfos
  2326. // that it will result in for http and ftp URLs. All that matters is that each
  2327. // ProxyConfig is different. It's important that none of these configs require
  2328. // fetching a PAC scripts, as this test checks
  2329. // ConfiguredProxyResolutionService::config(), which is only updated after
  2330. // fetching PAC scripts (if applicable).
  2331. struct ProxyConfigSet {
  2332. net::ProxyConfig proxy_config;
  2333. net::ProxyInfo http_proxy_info;
  2334. net::ProxyInfo ftp_proxy_info;
  2335. } proxy_config_sets[3];
  2336. proxy_config_sets[0].proxy_config.proxy_rules().ParseFromString(
  2337. "http=foopy:80");
  2338. proxy_config_sets[0].http_proxy_info.UsePacString("PROXY foopy:80");
  2339. proxy_config_sets[0].ftp_proxy_info.UseDirect();
  2340. proxy_config_sets[1].proxy_config.proxy_rules().ParseFromString(
  2341. "http=foopy:80;ftp=foopy2");
  2342. proxy_config_sets[1].http_proxy_info.UsePacString("PROXY foopy:80");
  2343. proxy_config_sets[1].ftp_proxy_info.UsePacString("PROXY foopy2");
  2344. proxy_config_sets[2].proxy_config = net::ProxyConfig::CreateDirect();
  2345. proxy_config_sets[2].http_proxy_info.UseDirect();
  2346. proxy_config_sets[2].ftp_proxy_info.UseDirect();
  2347. // Sanity check.
  2348. EXPECT_FALSE(proxy_config_sets[0].proxy_config.Equals(
  2349. proxy_config_sets[1].proxy_config));
  2350. EXPECT_FALSE(proxy_config_sets[0].proxy_config.Equals(
  2351. proxy_config_sets[2].proxy_config));
  2352. EXPECT_FALSE(proxy_config_sets[1].proxy_config.Equals(
  2353. proxy_config_sets[2].proxy_config));
  2354. // Try each proxy config as the initial config, to make sure setting the
  2355. // initial config works.
  2356. for (const auto& initial_proxy_config_set : proxy_config_sets) {
  2357. mojom::NetworkContextParamsPtr context_params =
  2358. CreateNetworkContextParamsForTesting();
  2359. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  2360. initial_proxy_config_set.proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS);
  2361. mojo::Remote<mojom::ProxyConfigClient> config_client;
  2362. context_params->proxy_config_client_receiver =
  2363. config_client.BindNewPipeAndPassReceiver();
  2364. std::unique_ptr<NetworkContext> network_context =
  2365. CreateContextWithParams(std::move(context_params));
  2366. net::ConfiguredProxyResolutionService* proxy_resolution_service = nullptr;
  2367. ASSERT_TRUE(network_context->url_request_context()
  2368. ->proxy_resolution_service()
  2369. ->CastToConfiguredProxyResolutionService(
  2370. &proxy_resolution_service));
  2371. // Need to do proxy resolutions before can check the ProxyConfig, as the
  2372. // ProxyService doesn't start updating its config until it's first used.
  2373. // This also gives some test coverage of LookUpProxyForURL.
  2374. TestProxyLookupClient http_proxy_lookup_client;
  2375. http_proxy_lookup_client.StartLookUpProxyForURL(
  2376. GURL("http://foo"), net::NetworkIsolationKey(), network_context.get());
  2377. http_proxy_lookup_client.WaitForResult();
  2378. ASSERT_TRUE(http_proxy_lookup_client.proxy_info());
  2379. EXPECT_EQ(initial_proxy_config_set.http_proxy_info.ToPacString(),
  2380. http_proxy_lookup_client.proxy_info()->ToPacString());
  2381. TestProxyLookupClient ftp_proxy_lookup_client;
  2382. ftp_proxy_lookup_client.StartLookUpProxyForURL(
  2383. GURL("ftp://foo"), net::NetworkIsolationKey(), network_context.get());
  2384. ftp_proxy_lookup_client.WaitForResult();
  2385. ASSERT_TRUE(ftp_proxy_lookup_client.proxy_info());
  2386. EXPECT_EQ(initial_proxy_config_set.ftp_proxy_info.ToPacString(),
  2387. ftp_proxy_lookup_client.proxy_info()->ToPacString());
  2388. EXPECT_TRUE(proxy_resolution_service->config());
  2389. EXPECT_TRUE(proxy_resolution_service->config()->value().Equals(
  2390. initial_proxy_config_set.proxy_config));
  2391. // Always go through the other configs in the same order. This has the
  2392. // advantage of testing the case where there's no change, for
  2393. // proxy_config[0].
  2394. for (const auto& proxy_config_set : proxy_config_sets) {
  2395. config_client->OnProxyConfigUpdated(net::ProxyConfigWithAnnotation(
  2396. proxy_config_set.proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS));
  2397. task_environment_.RunUntilIdle();
  2398. TestProxyLookupClient http_proxy_lookup_client2;
  2399. http_proxy_lookup_client2.StartLookUpProxyForURL(
  2400. GURL("http://foo"), net::NetworkIsolationKey(),
  2401. network_context.get());
  2402. http_proxy_lookup_client2.WaitForResult();
  2403. ASSERT_TRUE(http_proxy_lookup_client2.proxy_info());
  2404. EXPECT_EQ(proxy_config_set.http_proxy_info.ToPacString(),
  2405. http_proxy_lookup_client2.proxy_info()->ToPacString());
  2406. TestProxyLookupClient ftp_proxy_lookup_client2;
  2407. ftp_proxy_lookup_client2.StartLookUpProxyForURL(
  2408. GURL("ftp://foo"), net::NetworkIsolationKey(), network_context.get());
  2409. ftp_proxy_lookup_client2.WaitForResult();
  2410. ASSERT_TRUE(ftp_proxy_lookup_client2.proxy_info());
  2411. EXPECT_EQ(proxy_config_set.ftp_proxy_info.ToPacString(),
  2412. ftp_proxy_lookup_client2.proxy_info()->ToPacString());
  2413. EXPECT_TRUE(proxy_resolution_service->config());
  2414. EXPECT_TRUE(proxy_resolution_service->config()->value().Equals(
  2415. proxy_config_set.proxy_config));
  2416. }
  2417. }
  2418. }
  2419. // Verify that a proxy config works without a ProxyConfigClient PendingReceiver.
  2420. TEST_F(NetworkContextTest, StaticProxyConfig) {
  2421. net::ProxyConfig proxy_config;
  2422. proxy_config.proxy_rules().ParseFromString("http=foopy:80;ftp=foopy2");
  2423. mojom::NetworkContextParamsPtr context_params =
  2424. CreateNetworkContextParamsForTesting();
  2425. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  2426. proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS);
  2427. std::unique_ptr<NetworkContext> network_context =
  2428. CreateContextWithParams(std::move(context_params));
  2429. net::ConfiguredProxyResolutionService* proxy_resolution_service = nullptr;
  2430. ASSERT_TRUE(
  2431. network_context->url_request_context()
  2432. ->proxy_resolution_service()
  2433. ->CastToConfiguredProxyResolutionService(&proxy_resolution_service));
  2434. // Kick the ConfiguredProxyResolutionService into action, as it doesn't start
  2435. // updating its config until it's first used.
  2436. proxy_resolution_service->ForceReloadProxyConfig();
  2437. EXPECT_TRUE(proxy_resolution_service->config());
  2438. EXPECT_TRUE(proxy_resolution_service->config()->value().Equals(proxy_config));
  2439. }
  2440. TEST_F(NetworkContextTest, NoInitialProxyConfig) {
  2441. mojom::NetworkContextParamsPtr context_params =
  2442. CreateNetworkContextParamsForTesting();
  2443. context_params->initial_proxy_config.reset();
  2444. mojo::Remote<mojom::ProxyConfigClient> config_client;
  2445. context_params->proxy_config_client_receiver =
  2446. config_client.BindNewPipeAndPassReceiver();
  2447. std::unique_ptr<NetworkContext> network_context =
  2448. CreateContextWithParams(std::move(context_params));
  2449. net::ConfiguredProxyResolutionService* proxy_resolution_service = nullptr;
  2450. ASSERT_TRUE(
  2451. network_context->url_request_context()
  2452. ->proxy_resolution_service()
  2453. ->CastToConfiguredProxyResolutionService(&proxy_resolution_service));
  2454. EXPECT_FALSE(proxy_resolution_service->config());
  2455. EXPECT_FALSE(proxy_resolution_service->fetched_config());
  2456. // Before there's a proxy configuration, proxy requests should hang.
  2457. // Create two lookups, to make sure two simultaneous lookups can be handled at
  2458. // once.
  2459. TestProxyLookupClient http_proxy_lookup_client;
  2460. http_proxy_lookup_client.StartLookUpProxyForURL(
  2461. GURL("http://foo/"), net::NetworkIsolationKey(), network_context.get());
  2462. TestProxyLookupClient ftp_proxy_lookup_client;
  2463. ftp_proxy_lookup_client.StartLookUpProxyForURL(
  2464. GURL("ftp://foo/"), net::NetworkIsolationKey(), network_context.get());
  2465. task_environment_.RunUntilIdle();
  2466. EXPECT_FALSE(proxy_resolution_service->config());
  2467. EXPECT_FALSE(proxy_resolution_service->fetched_config());
  2468. EXPECT_FALSE(http_proxy_lookup_client.is_done());
  2469. EXPECT_FALSE(ftp_proxy_lookup_client.is_done());
  2470. EXPECT_EQ(2u, network_context->pending_proxy_lookup_requests_for_testing());
  2471. net::ProxyConfig proxy_config;
  2472. proxy_config.proxy_rules().ParseFromString("http=foopy:80");
  2473. config_client->OnProxyConfigUpdated(net::ProxyConfigWithAnnotation(
  2474. proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS));
  2475. http_proxy_lookup_client.WaitForResult();
  2476. ASSERT_TRUE(http_proxy_lookup_client.proxy_info());
  2477. EXPECT_EQ("PROXY foopy:80",
  2478. http_proxy_lookup_client.proxy_info()->ToPacString());
  2479. ftp_proxy_lookup_client.WaitForResult();
  2480. ASSERT_TRUE(ftp_proxy_lookup_client.proxy_info());
  2481. EXPECT_EQ("DIRECT", ftp_proxy_lookup_client.proxy_info()->ToPacString());
  2482. EXPECT_EQ(0u, network_context->pending_proxy_lookup_requests_for_testing());
  2483. }
  2484. TEST_F(NetworkContextTest, DestroyedWithoutProxyConfig) {
  2485. // Create a NetworkContext without an initial proxy configuration.
  2486. mojom::NetworkContextParamsPtr context_params =
  2487. CreateNetworkContextParamsForTesting();
  2488. context_params->initial_proxy_config.reset();
  2489. mojo::Remote<mojom::ProxyConfigClient> config_client;
  2490. context_params->proxy_config_client_receiver =
  2491. config_client.BindNewPipeAndPassReceiver();
  2492. std::unique_ptr<NetworkContext> network_context =
  2493. CreateContextWithParams(std::move(context_params));
  2494. // Proxy requests should hang.
  2495. TestProxyLookupClient proxy_lookup_client;
  2496. proxy_lookup_client.StartLookUpProxyForURL(
  2497. GURL("http://foo/"), net::NetworkIsolationKey(), network_context.get());
  2498. task_environment_.RunUntilIdle();
  2499. EXPECT_EQ(1u, network_context->pending_proxy_lookup_requests_for_testing());
  2500. EXPECT_FALSE(proxy_lookup_client.is_done());
  2501. // Destroying the NetworkContext should cause the pending lookup to fail with
  2502. // ERR_ABORTED.
  2503. network_context.reset();
  2504. proxy_lookup_client.WaitForResult();
  2505. EXPECT_FALSE(proxy_lookup_client.proxy_info());
  2506. EXPECT_EQ(net::ERR_ABORTED, proxy_lookup_client.net_error());
  2507. }
  2508. TEST_F(NetworkContextTest, CancelPendingProxyLookup) {
  2509. // Create a NetworkContext without an initial proxy configuration.
  2510. mojom::NetworkContextParamsPtr context_params =
  2511. CreateNetworkContextParamsForTesting();
  2512. context_params->initial_proxy_config.reset();
  2513. mojo::Remote<mojom::ProxyConfigClient> config_client;
  2514. context_params->proxy_config_client_receiver =
  2515. config_client.BindNewPipeAndPassReceiver();
  2516. std::unique_ptr<NetworkContext> network_context =
  2517. CreateContextWithParams(std::move(context_params));
  2518. // Proxy requests should hang.
  2519. std::unique_ptr<TestProxyLookupClient> proxy_lookup_client =
  2520. std::make_unique<TestProxyLookupClient>();
  2521. proxy_lookup_client->StartLookUpProxyForURL(
  2522. GURL("http://foo/"), net::NetworkIsolationKey(), network_context.get());
  2523. task_environment_.RunUntilIdle();
  2524. EXPECT_FALSE(proxy_lookup_client->is_done());
  2525. EXPECT_EQ(1u, network_context->pending_proxy_lookup_requests_for_testing());
  2526. // Cancelling the proxy lookup should cause the proxy lookup request objects
  2527. // to be deleted.
  2528. proxy_lookup_client.reset();
  2529. task_environment_.RunUntilIdle();
  2530. EXPECT_EQ(0u, network_context->pending_proxy_lookup_requests_for_testing());
  2531. }
  2532. // Test to make sure the NetworkIsolationKey passed to LookUpProxyForURL() makes
  2533. // it to the proxy resolver.
  2534. TEST_F(NetworkContextTest, ProxyLookupWithNetworkIsolationKey) {
  2535. const GURL kUrl("http://bar.test/");
  2536. const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.test/"));
  2537. const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
  2538. // Pac scripts must contain this string to be passed to the
  2539. // ProxyResolverFactory.
  2540. const std::string kPacScript("FindProxyForURL");
  2541. // Create a NetworkContext without an initial proxy configuration.
  2542. mojom::NetworkContextParamsPtr context_params =
  2543. CreateNetworkContextParamsForTesting();
  2544. CapturingMojoProxyResolverFactory proxy_resolver_factory;
  2545. context_params->proxy_resolver_factory =
  2546. proxy_resolver_factory.CreateFactoryRemote();
  2547. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  2548. net::ProxyConfig::CreateFromCustomPacURL(GURL("data:," + kPacScript)),
  2549. TRAFFIC_ANNOTATION_FOR_TESTS);
  2550. mojo::Remote<mojom::ProxyConfigClient> config_client;
  2551. context_params->proxy_config_client_receiver =
  2552. config_client.BindNewPipeAndPassReceiver();
  2553. #if BUILDFLAG(IS_CHROMEOS_ASH)
  2554. context_params->dhcp_wpad_url_client =
  2555. network::MockMojoDhcpWpadUrlClient::CreateWithSelfOwnedReceiver(
  2556. std::string());
  2557. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  2558. std::unique_ptr<NetworkContext> network_context =
  2559. CreateContextWithParams(std::move(context_params));
  2560. TestProxyLookupClient proxy_lookup_client;
  2561. proxy_lookup_client.StartLookUpProxyForURL(kUrl, kNetworkIsolationKey,
  2562. network_context.get());
  2563. proxy_lookup_client.WaitForResult();
  2564. ASSERT_TRUE(proxy_lookup_client.proxy_info());
  2565. EXPECT_TRUE(proxy_lookup_client.proxy_info()->is_direct_only());
  2566. EXPECT_EQ(kPacScript, proxy_resolver_factory.pac_script());
  2567. EXPECT_EQ(kUrl, proxy_resolver_factory.url());
  2568. EXPECT_EQ(kNetworkIsolationKey,
  2569. proxy_resolver_factory.network_isolation_key());
  2570. }
  2571. // Test mojom::ProxyResolver that completes calls to GetProxyForUrl() with a
  2572. // DIRECT "proxy". It additionally emits a script error on line 42 for every
  2573. // call to GetProxyForUrl().
  2574. class MockMojoProxyResolver : public proxy_resolver::mojom::ProxyResolver {
  2575. public:
  2576. MockMojoProxyResolver() {}
  2577. MockMojoProxyResolver(const MockMojoProxyResolver&) = delete;
  2578. MockMojoProxyResolver& operator=(const MockMojoProxyResolver&) = delete;
  2579. private:
  2580. // Overridden from proxy_resolver::mojom::ProxyResolver:
  2581. void GetProxyForUrl(
  2582. const GURL& url,
  2583. const net::NetworkIsolationKey& network_isolation_key,
  2584. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverRequestClient>
  2585. pending_client) override {
  2586. // Report a Javascript error and then complete the request successfully,
  2587. // having chosen DIRECT connections.
  2588. mojo::Remote<proxy_resolver::mojom::ProxyResolverRequestClient> client(
  2589. std::move(pending_client));
  2590. client->OnError(42, "Failed: FindProxyForURL(url=" + url.spec() + ")");
  2591. net::ProxyInfo result;
  2592. result.UseDirect();
  2593. client->ReportResult(net::OK, result);
  2594. }
  2595. };
  2596. // Test mojom::ProxyResolverFactory implementation that successfully completes
  2597. // any CreateResolver() requests, and binds the request to a new
  2598. // MockMojoProxyResolver.
  2599. class MockMojoProxyResolverFactory
  2600. : public proxy_resolver::mojom::ProxyResolverFactory {
  2601. public:
  2602. MockMojoProxyResolverFactory() {}
  2603. MockMojoProxyResolverFactory(const MockMojoProxyResolverFactory&) = delete;
  2604. MockMojoProxyResolverFactory& operator=(const MockMojoProxyResolverFactory&) =
  2605. delete;
  2606. // Binds and returns a mock ProxyResolverFactory whose lifetime is bound to
  2607. // the message pipe.
  2608. static mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverFactory>
  2609. Create() {
  2610. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverFactory> remote;
  2611. mojo::MakeSelfOwnedReceiver(
  2612. std::make_unique<MockMojoProxyResolverFactory>(),
  2613. remote.InitWithNewPipeAndPassReceiver());
  2614. return remote;
  2615. }
  2616. private:
  2617. void CreateResolver(
  2618. const std::string& pac_url,
  2619. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver,
  2620. mojo::PendingRemote<
  2621. proxy_resolver::mojom::ProxyResolverFactoryRequestClient>
  2622. pending_client) override {
  2623. // Bind |receiver| to a new MockMojoProxyResolver, and return success.
  2624. mojo::MakeSelfOwnedReceiver(std::make_unique<MockMojoProxyResolver>(),
  2625. std::move(receiver));
  2626. mojo::Remote<proxy_resolver::mojom::ProxyResolverFactoryRequestClient>
  2627. client(std::move(pending_client));
  2628. client->ReportResult(net::OK);
  2629. }
  2630. };
  2631. TEST_F(NetworkContextTest, PacQuickCheck) {
  2632. // Check the default value.
  2633. // Note that unless we explicitly create a proxy resolver factory, the code
  2634. // will assume that we should use a system proxy resolver (i.e. use system
  2635. // APIs to resolve a proxy). This isn't supported on all platforms. On
  2636. // unsupported platforms, we'd simply ignore the PAC quick check input and
  2637. // default to false.
  2638. mojom::NetworkContextParamsPtr context_params =
  2639. CreateNetworkContextParamsForTesting();
  2640. #if BUILDFLAG(IS_CHROMEOS_ASH)
  2641. context_params->dhcp_wpad_url_client =
  2642. network::MockMojoDhcpWpadUrlClient::CreateWithSelfOwnedReceiver(
  2643. std::string());
  2644. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  2645. context_params->proxy_resolver_factory =
  2646. MockMojoProxyResolverFactory::Create();
  2647. std::unique_ptr<NetworkContext> network_context =
  2648. CreateContextWithParams(std::move(context_params));
  2649. net::ConfiguredProxyResolutionService* proxy_resolution_service = nullptr;
  2650. ASSERT_TRUE(
  2651. network_context->url_request_context()
  2652. ->proxy_resolution_service()
  2653. ->CastToConfiguredProxyResolutionService(&proxy_resolution_service));
  2654. EXPECT_TRUE(proxy_resolution_service->quick_check_enabled_for_testing());
  2655. // Explicitly enable.
  2656. context_params = CreateNetworkContextParamsForTesting();
  2657. #if BUILDFLAG(IS_CHROMEOS_ASH)
  2658. context_params->dhcp_wpad_url_client =
  2659. network::MockMojoDhcpWpadUrlClient::CreateWithSelfOwnedReceiver(
  2660. std::string());
  2661. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  2662. context_params->proxy_resolver_factory =
  2663. MockMojoProxyResolverFactory::Create();
  2664. context_params->pac_quick_check_enabled = true;
  2665. network_context = CreateContextWithParams(std::move(context_params));
  2666. proxy_resolution_service = nullptr;
  2667. ASSERT_TRUE(
  2668. network_context->url_request_context()
  2669. ->proxy_resolution_service()
  2670. ->CastToConfiguredProxyResolutionService(&proxy_resolution_service));
  2671. EXPECT_TRUE(proxy_resolution_service->quick_check_enabled_for_testing());
  2672. // Explicitly disable.
  2673. context_params = CreateNetworkContextParamsForTesting();
  2674. #if BUILDFLAG(IS_CHROMEOS_ASH)
  2675. context_params->dhcp_wpad_url_client =
  2676. network::MockMojoDhcpWpadUrlClient::CreateWithSelfOwnedReceiver(
  2677. std::string());
  2678. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  2679. context_params->proxy_resolver_factory =
  2680. MockMojoProxyResolverFactory::Create();
  2681. context_params->pac_quick_check_enabled = false;
  2682. network_context = CreateContextWithParams(std::move(context_params));
  2683. proxy_resolution_service = nullptr;
  2684. ASSERT_TRUE(
  2685. network_context->url_request_context()
  2686. ->proxy_resolution_service()
  2687. ->CastToConfiguredProxyResolutionService(&proxy_resolution_service));
  2688. EXPECT_FALSE(proxy_resolution_service->quick_check_enabled_for_testing());
  2689. }
  2690. net::IPEndPoint GetLocalHostWithAnyPort() {
  2691. return net::IPEndPoint(net::IPAddress(127, 0, 0, 1), 0);
  2692. }
  2693. std::vector<uint8_t> CreateTestMessage(uint8_t initial, size_t size) {
  2694. std::vector<uint8_t> array(size);
  2695. for (size_t i = 0; i < size; ++i)
  2696. array[i] = static_cast<uint8_t>((i + initial) % 256);
  2697. return array;
  2698. }
  2699. TEST_F(NetworkContextTest, CreateUDPSocket) {
  2700. std::unique_ptr<NetworkContext> network_context =
  2701. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2702. // Create a server socket to listen for incoming datagrams.
  2703. test::UDPSocketListenerImpl listener;
  2704. mojo::Receiver<mojom::UDPSocketListener> listener_receiver(&listener);
  2705. net::IPEndPoint server_addr(GetLocalHostWithAnyPort());
  2706. mojo::Remote<mojom::UDPSocket> server_socket;
  2707. network_context->CreateUDPSocket(
  2708. server_socket.BindNewPipeAndPassReceiver(),
  2709. listener_receiver.BindNewPipeAndPassRemote());
  2710. test::UDPSocketTestHelper helper(&server_socket);
  2711. ASSERT_EQ(net::OK, helper.BindSync(server_addr, nullptr, &server_addr));
  2712. // Create a client socket to send datagrams.
  2713. mojo::Remote<mojom::UDPSocket> client_socket;
  2714. network_context->CreateUDPSocket(client_socket.BindNewPipeAndPassReceiver(),
  2715. mojo::NullRemote());
  2716. net::IPEndPoint client_addr(GetLocalHostWithAnyPort());
  2717. test::UDPSocketTestHelper client_helper(&client_socket);
  2718. ASSERT_EQ(net::OK,
  2719. client_helper.ConnectSync(server_addr, nullptr, &client_addr));
  2720. // This test assumes that the loopback interface doesn't drop UDP packets for
  2721. // a small number of packets.
  2722. const size_t kDatagramCount = 6;
  2723. const size_t kDatagramSize = 255;
  2724. server_socket->ReceiveMore(kDatagramCount);
  2725. for (size_t i = 0; i < kDatagramCount; ++i) {
  2726. std::vector<uint8_t> test_msg(
  2727. CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize));
  2728. int result = client_helper.SendSync(test_msg);
  2729. EXPECT_EQ(net::OK, result);
  2730. }
  2731. listener.WaitForReceivedResults(kDatagramCount);
  2732. EXPECT_EQ(kDatagramCount, listener.results().size());
  2733. int i = 0;
  2734. for (const auto& result : listener.results()) {
  2735. EXPECT_EQ(net::OK, result.net_error);
  2736. EXPECT_EQ(result.src_addr, client_addr);
  2737. EXPECT_EQ(CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize),
  2738. result.data.value());
  2739. i++;
  2740. }
  2741. }
  2742. TEST_F(NetworkContextTest, CreateNetLogExporter) {
  2743. // Basic flow around start/stop.
  2744. std::unique_ptr<NetworkContext> network_context =
  2745. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2746. mojo::Remote<mojom::NetLogExporter> net_log_exporter;
  2747. network_context->CreateNetLogExporter(
  2748. net_log_exporter.BindNewPipeAndPassReceiver());
  2749. base::ScopedTempDir temp_dir;
  2750. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  2751. base::FilePath out_path(temp_dir.GetPath().AppendASCII("out.json"));
  2752. base::File out_file(out_path,
  2753. base::File::FLAG_CREATE | base::File::FLAG_WRITE);
  2754. ASSERT_TRUE(out_file.IsValid());
  2755. base::Value::Dict dict_start;
  2756. const char kKeyEarly[] = "early";
  2757. const char kValEarly[] = "morning";
  2758. dict_start.Set(kKeyEarly, kValEarly);
  2759. net::TestCompletionCallback start_callback;
  2760. net_log_exporter->Start(std::move(out_file), std::move(dict_start),
  2761. net::NetLogCaptureMode::kDefault, 100 * 1024,
  2762. start_callback.callback());
  2763. EXPECT_EQ(net::OK, start_callback.WaitForResult());
  2764. base::Value::Dict dict_late;
  2765. const char kKeyLate[] = "late";
  2766. const char kValLate[] = "snowval";
  2767. dict_late.Set(kKeyLate, kValLate);
  2768. net::TestCompletionCallback stop_callback;
  2769. net_log_exporter->Stop(std::move(dict_late), stop_callback.callback());
  2770. EXPECT_EQ(net::OK, stop_callback.WaitForResult());
  2771. // Check that file got written.
  2772. std::string contents;
  2773. ASSERT_TRUE(base::ReadFileToString(out_path, &contents));
  2774. // Contents should have net constants, without the client needing any
  2775. // net:: methods.
  2776. EXPECT_NE(std::string::npos, contents.find("ERR_IO_PENDING")) << contents;
  2777. // The additional stuff inject should also occur someplace.
  2778. EXPECT_NE(std::string::npos, contents.find(kKeyEarly)) << contents;
  2779. EXPECT_NE(std::string::npos, contents.find(kValEarly)) << contents;
  2780. EXPECT_NE(std::string::npos, contents.find(kKeyLate)) << contents;
  2781. EXPECT_NE(std::string::npos, contents.find(kValLate)) << contents;
  2782. }
  2783. TEST_F(NetworkContextTest, CreateNetLogExporterUnbounded) {
  2784. // Make sure that exporting without size limit works.
  2785. std::unique_ptr<NetworkContext> network_context =
  2786. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2787. mojo::Remote<mojom::NetLogExporter> net_log_exporter;
  2788. network_context->CreateNetLogExporter(
  2789. net_log_exporter.BindNewPipeAndPassReceiver());
  2790. base::FilePath temp_path;
  2791. ASSERT_TRUE(base::CreateTemporaryFile(&temp_path));
  2792. base::File out_file(temp_path,
  2793. base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  2794. ASSERT_TRUE(out_file.IsValid());
  2795. net::TestCompletionCallback start_callback;
  2796. net_log_exporter->Start(std::move(out_file), base::Value::Dict(),
  2797. net::NetLogCaptureMode::kDefault,
  2798. mojom::NetLogExporter::kUnlimitedFileSize,
  2799. start_callback.callback());
  2800. EXPECT_EQ(net::OK, start_callback.WaitForResult());
  2801. net::TestCompletionCallback stop_callback;
  2802. net_log_exporter->Stop(base::Value::Dict(), stop_callback.callback());
  2803. EXPECT_EQ(net::OK, stop_callback.WaitForResult());
  2804. // Check that file got written.
  2805. std::string contents;
  2806. ASSERT_TRUE(base::ReadFileToString(temp_path, &contents));
  2807. // Contents should have net constants, without the client needing any
  2808. // net:: methods.
  2809. EXPECT_NE(std::string::npos, contents.find("ERR_IO_PENDING")) << contents;
  2810. base::DeleteFile(temp_path);
  2811. }
  2812. TEST_F(NetworkContextTest, CreateNetLogExporterErrors) {
  2813. // Some basic state machine misuses.
  2814. std::unique_ptr<NetworkContext> network_context =
  2815. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2816. mojo::Remote<mojom::NetLogExporter> net_log_exporter;
  2817. network_context->CreateNetLogExporter(
  2818. net_log_exporter.BindNewPipeAndPassReceiver());
  2819. net::TestCompletionCallback stop_callback;
  2820. net_log_exporter->Stop(base::Value::Dict(), stop_callback.callback());
  2821. EXPECT_EQ(net::ERR_UNEXPECTED, stop_callback.WaitForResult());
  2822. base::FilePath temp_path;
  2823. ASSERT_TRUE(base::CreateTemporaryFile(&temp_path));
  2824. base::File temp_file(temp_path,
  2825. base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  2826. ASSERT_TRUE(temp_file.IsValid());
  2827. net::TestCompletionCallback start_callback;
  2828. net_log_exporter->Start(std::move(temp_file), base::Value::Dict(),
  2829. net::NetLogCaptureMode::kDefault, 100 * 1024,
  2830. start_callback.callback());
  2831. EXPECT_EQ(net::OK, start_callback.WaitForResult());
  2832. // Can't start twice.
  2833. base::FilePath temp_path2;
  2834. ASSERT_TRUE(base::CreateTemporaryFile(&temp_path2));
  2835. base::File temp_file2(
  2836. temp_path2, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  2837. ASSERT_TRUE(temp_file2.IsValid());
  2838. net::TestCompletionCallback start_callback2;
  2839. net_log_exporter->Start(std::move(temp_file2), base::Value::Dict(),
  2840. net::NetLogCaptureMode::kDefault, 100 * 1024,
  2841. start_callback2.callback());
  2842. EXPECT_EQ(net::ERR_UNEXPECTED, start_callback2.WaitForResult());
  2843. base::DeleteFile(temp_path);
  2844. base::DeleteFile(temp_path2);
  2845. // Forgetting to stop is recovered from.
  2846. }
  2847. TEST_F(NetworkContextTest, DestroyNetLogExporterWhileCreatingScratchDir) {
  2848. // Make sure that things behave OK if NetLogExporter is destroyed during the
  2849. // brief window it owns the scratch directory.
  2850. std::unique_ptr<NetworkContext> network_context =
  2851. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2852. std::unique_ptr<NetLogExporter> net_log_exporter =
  2853. std::make_unique<NetLogExporter>(network_context.get());
  2854. base::WaitableEvent block_mktemp(
  2855. base::WaitableEvent::ResetPolicy::MANUAL,
  2856. base::WaitableEvent::InitialState::NOT_SIGNALED);
  2857. base::ScopedTempDir dir;
  2858. ASSERT_TRUE(dir.CreateUniqueTempDir());
  2859. base::FilePath path = dir.Take();
  2860. EXPECT_TRUE(base::PathExists(path));
  2861. net_log_exporter->SetCreateScratchDirHandlerForTesting(base::BindRepeating(
  2862. [](base::WaitableEvent* block_on,
  2863. const base::FilePath& path) -> base::FilePath {
  2864. base::ScopedAllowBaseSyncPrimitivesForTesting need_to_block;
  2865. block_on->Wait();
  2866. return path;
  2867. },
  2868. &block_mktemp, path));
  2869. base::FilePath temp_path;
  2870. ASSERT_TRUE(base::CreateTemporaryFile(&temp_path));
  2871. base::File temp_file(temp_path,
  2872. base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  2873. ASSERT_TRUE(temp_file.IsValid());
  2874. net_log_exporter->Start(std::move(temp_file), base::Value::Dict(),
  2875. net::NetLogCaptureMode::kDefault, 100,
  2876. base::BindOnce([](int) {}));
  2877. net_log_exporter = nullptr;
  2878. block_mktemp.Signal();
  2879. task_environment_.RunUntilIdle();
  2880. EXPECT_FALSE(base::PathExists(path));
  2881. base::DeleteFile(temp_path);
  2882. }
  2883. net::IPEndPoint CreateExpectedEndPoint(const std::string& address,
  2884. uint16_t port) {
  2885. net::IPAddress ip_address;
  2886. CHECK(ip_address.AssignFromIPLiteral(address));
  2887. return net::IPEndPoint(ip_address, port);
  2888. }
  2889. class TestResolveHostClient : public ResolveHostClientBase {
  2890. public:
  2891. TestResolveHostClient(mojo::PendingRemote<mojom::ResolveHostClient>* remote,
  2892. base::RunLoop* run_loop)
  2893. : receiver_(this, remote->InitWithNewPipeAndPassReceiver()),
  2894. complete_(false),
  2895. run_loop_(run_loop) {
  2896. DCHECK(run_loop_);
  2897. }
  2898. void CloseReceiver() { receiver_.reset(); }
  2899. void OnComplete(int error,
  2900. const net::ResolveErrorInfo& resolve_error_info,
  2901. const absl::optional<net::AddressList>& addresses) override {
  2902. DCHECK(!complete_);
  2903. complete_ = true;
  2904. top_level_result_error_ = error;
  2905. result_error_ = resolve_error_info.error;
  2906. result_addresses_ = addresses;
  2907. run_loop_->Quit();
  2908. }
  2909. bool complete() const { return complete_; }
  2910. int top_level_result_error() const {
  2911. DCHECK(complete_);
  2912. return top_level_result_error_;
  2913. }
  2914. int result_error() const {
  2915. DCHECK(complete_);
  2916. return result_error_;
  2917. }
  2918. const absl::optional<net::AddressList>& result_addresses() const {
  2919. DCHECK(complete_);
  2920. return result_addresses_;
  2921. }
  2922. private:
  2923. mojo::Receiver<mojom::ResolveHostClient> receiver_;
  2924. bool complete_;
  2925. int top_level_result_error_;
  2926. int result_error_;
  2927. absl::optional<net::AddressList> result_addresses_;
  2928. const raw_ptr<base::RunLoop> run_loop_;
  2929. };
  2930. TEST_F(NetworkContextTest, ResolveHost_Sync) {
  2931. auto resolver = std::make_unique<net::MockHostResolver>();
  2932. resolver->rules()->AddRule("sync.test", "1.2.3.4");
  2933. resolver->set_synchronous_mode(true);
  2934. network_service_->set_host_resolver_factory_for_testing(
  2935. std::make_unique<HostResolverFactory>(std::move(resolver)));
  2936. std::unique_ptr<NetworkContext> network_context =
  2937. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2938. base::RunLoop run_loop;
  2939. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  2940. mojom::ResolveHostParametersPtr optional_parameters =
  2941. mojom::ResolveHostParameters::New();
  2942. optional_parameters->control_handle =
  2943. control_handle.BindNewPipeAndPassReceiver();
  2944. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  2945. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  2946. network_context->ResolveHost(
  2947. net::HostPortPair("sync.test", 160), net::NetworkIsolationKey(),
  2948. std::move(optional_parameters), std::move(pending_response_client));
  2949. run_loop.Run();
  2950. EXPECT_EQ(net::OK, response_client.top_level_result_error());
  2951. EXPECT_EQ(net::OK, response_client.result_error());
  2952. EXPECT_THAT(
  2953. response_client.result_addresses().value().endpoints(),
  2954. testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  2955. EXPECT_EQ(0u,
  2956. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  2957. }
  2958. TEST_F(NetworkContextTest, ResolveHost_Async) {
  2959. auto resolver = std::make_unique<net::MockHostResolver>();
  2960. resolver->rules()->AddRule("async.test", "1.2.3.4");
  2961. resolver->set_synchronous_mode(false);
  2962. network_service_->set_host_resolver_factory_for_testing(
  2963. std::make_unique<HostResolverFactory>(std::move(resolver)));
  2964. std::unique_ptr<NetworkContext> network_context =
  2965. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2966. base::RunLoop run_loop;
  2967. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  2968. mojom::ResolveHostParametersPtr optional_parameters =
  2969. mojom::ResolveHostParameters::New();
  2970. optional_parameters->control_handle =
  2971. control_handle.BindNewPipeAndPassReceiver();
  2972. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  2973. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  2974. network_context->ResolveHost(
  2975. net::HostPortPair("async.test", 160), net::NetworkIsolationKey(),
  2976. std::move(optional_parameters), std::move(pending_response_client));
  2977. bool control_handle_closed = false;
  2978. auto connection_error_callback =
  2979. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  2980. control_handle.set_disconnect_handler(connection_error_callback);
  2981. run_loop.Run();
  2982. EXPECT_EQ(net::OK, response_client.top_level_result_error());
  2983. EXPECT_EQ(net::OK, response_client.result_error());
  2984. EXPECT_THAT(
  2985. response_client.result_addresses().value().endpoints(),
  2986. testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  2987. EXPECT_TRUE(control_handle_closed);
  2988. EXPECT_EQ(0u,
  2989. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  2990. }
  2991. TEST_F(NetworkContextTest, ResolveHost_Failure_Sync) {
  2992. auto resolver = std::make_unique<net::MockHostResolver>();
  2993. resolver->rules()->AddSimulatedTimeoutFailure("example.com");
  2994. resolver->set_synchronous_mode(true);
  2995. network_service_->set_host_resolver_factory_for_testing(
  2996. std::make_unique<HostResolverFactory>(std::move(resolver)));
  2997. std::unique_ptr<NetworkContext> network_context =
  2998. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  2999. base::RunLoop run_loop;
  3000. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3001. mojom::ResolveHostParametersPtr optional_parameters =
  3002. mojom::ResolveHostParameters::New();
  3003. optional_parameters->control_handle =
  3004. control_handle.BindNewPipeAndPassReceiver();
  3005. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3006. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3007. network_context->ResolveHost(
  3008. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  3009. std::move(optional_parameters), std::move(pending_response_client));
  3010. run_loop.Run();
  3011. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED,
  3012. response_client.top_level_result_error());
  3013. EXPECT_EQ(net::ERR_DNS_TIMED_OUT, response_client.result_error());
  3014. EXPECT_FALSE(response_client.result_addresses());
  3015. EXPECT_EQ(0u,
  3016. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3017. }
  3018. TEST_F(NetworkContextTest, ResolveHost_Failure_Async) {
  3019. auto resolver = std::make_unique<net::MockHostResolver>();
  3020. resolver->rules()->AddSimulatedTimeoutFailure("example.com");
  3021. resolver->set_synchronous_mode(false);
  3022. network_service_->set_host_resolver_factory_for_testing(
  3023. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3024. std::unique_ptr<NetworkContext> network_context =
  3025. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3026. base::RunLoop run_loop;
  3027. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3028. mojom::ResolveHostParametersPtr optional_parameters =
  3029. mojom::ResolveHostParameters::New();
  3030. optional_parameters->control_handle =
  3031. control_handle.BindNewPipeAndPassReceiver();
  3032. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3033. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3034. network_context->ResolveHost(
  3035. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  3036. std::move(optional_parameters), std::move(pending_response_client));
  3037. bool control_handle_closed = false;
  3038. auto connection_error_callback =
  3039. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3040. control_handle.set_disconnect_handler(connection_error_callback);
  3041. run_loop.Run();
  3042. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED,
  3043. response_client.top_level_result_error());
  3044. EXPECT_EQ(net::ERR_DNS_TIMED_OUT, response_client.result_error());
  3045. EXPECT_FALSE(response_client.result_addresses());
  3046. EXPECT_TRUE(control_handle_closed);
  3047. EXPECT_EQ(0u,
  3048. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3049. }
  3050. TEST_F(NetworkContextTest, ResolveHost_NetworkIsolationKey) {
  3051. const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.test/"));
  3052. const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
  3053. auto resolver = std::make_unique<net::MockHostResolver>();
  3054. resolver->rules()->AddRule("nik.test", "1.2.3.4");
  3055. net::MockHostResolver* raw_resolver = resolver.get();
  3056. network_service_->set_host_resolver_factory_for_testing(
  3057. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3058. std::unique_ptr<NetworkContext> network_context =
  3059. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3060. base::RunLoop run_loop;
  3061. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3062. mojom::ResolveHostParametersPtr optional_parameters =
  3063. mojom::ResolveHostParameters::New();
  3064. optional_parameters->control_handle =
  3065. control_handle.BindNewPipeAndPassReceiver();
  3066. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3067. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3068. network_context->ResolveHost(
  3069. net::HostPortPair("nik.test", 160), kNetworkIsolationKey,
  3070. std::move(optional_parameters), std::move(pending_response_client));
  3071. run_loop.Run();
  3072. EXPECT_EQ(net::OK, response_client.result_error());
  3073. EXPECT_THAT(
  3074. response_client.result_addresses().value().endpoints(),
  3075. testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  3076. EXPECT_EQ(0u,
  3077. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3078. EXPECT_EQ(kNetworkIsolationKey,
  3079. raw_resolver->last_request_network_isolation_key());
  3080. }
  3081. TEST_F(NetworkContextTest, ResolveHost_NoControlHandle) {
  3082. std::unique_ptr<NetworkContext> network_context =
  3083. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3084. base::RunLoop run_loop;
  3085. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3086. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3087. // Resolve "localhost" because it should always resolve fast and locally, even
  3088. // when using a real HostResolver.
  3089. network_context->ResolveHost(net::HostPortPair("localhost", 80),
  3090. net::NetworkIsolationKey(), nullptr,
  3091. std::move(pending_response_client));
  3092. run_loop.Run();
  3093. EXPECT_EQ(net::OK, response_client.result_error());
  3094. EXPECT_THAT(
  3095. response_client.result_addresses().value().endpoints(),
  3096. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  3097. CreateExpectedEndPoint("::1", 80)));
  3098. EXPECT_EQ(0u,
  3099. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3100. }
  3101. TEST_F(NetworkContextTest, ResolveHost_CloseControlHandle) {
  3102. std::unique_ptr<NetworkContext> network_context =
  3103. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3104. base::RunLoop run_loop;
  3105. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3106. mojom::ResolveHostParametersPtr optional_parameters =
  3107. mojom::ResolveHostParameters::New();
  3108. optional_parameters->control_handle =
  3109. control_handle.BindNewPipeAndPassReceiver();
  3110. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3111. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3112. // Resolve "localhost" because it should always resolve fast and locally, even
  3113. // when using a real HostResolver.
  3114. network_context->ResolveHost(
  3115. net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
  3116. std::move(optional_parameters), std::move(pending_response_client));
  3117. control_handle.reset();
  3118. run_loop.Run();
  3119. EXPECT_EQ(net::OK, response_client.result_error());
  3120. EXPECT_THAT(
  3121. response_client.result_addresses().value().endpoints(),
  3122. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160),
  3123. CreateExpectedEndPoint("::1", 160)));
  3124. EXPECT_EQ(0u,
  3125. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3126. }
  3127. TEST_F(NetworkContextTest, ResolveHost_Cancellation) {
  3128. // Override the HostResolver with a hanging one, so the test can ensure the
  3129. // request won't be completed before the cancellation arrives.
  3130. auto resolver = std::make_unique<net::HangingHostResolver>();
  3131. scoped_refptr<const net::HangingHostResolver::State> state =
  3132. resolver->state();
  3133. network_service_->set_host_resolver_factory_for_testing(
  3134. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3135. std::unique_ptr<NetworkContext> network_context =
  3136. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3137. ASSERT_EQ(0, state->num_cancellations());
  3138. base::RunLoop run_loop;
  3139. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3140. mojom::ResolveHostParametersPtr optional_parameters =
  3141. mojom::ResolveHostParameters::New();
  3142. optional_parameters->control_handle =
  3143. control_handle.BindNewPipeAndPassReceiver();
  3144. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3145. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3146. network_context->ResolveHost(
  3147. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  3148. std::move(optional_parameters), std::move(pending_response_client));
  3149. bool control_handle_closed = false;
  3150. auto connection_error_callback =
  3151. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3152. control_handle.set_disconnect_handler(connection_error_callback);
  3153. control_handle->Cancel(net::ERR_ABORTED);
  3154. run_loop.Run();
  3155. // On cancellation, should receive an ERR_FAILED result, and the internal
  3156. // resolver request should have been cancelled.
  3157. EXPECT_EQ(net::ERR_ABORTED, response_client.result_error());
  3158. EXPECT_FALSE(response_client.result_addresses());
  3159. EXPECT_EQ(1, state->num_cancellations());
  3160. EXPECT_TRUE(control_handle_closed);
  3161. EXPECT_EQ(0u,
  3162. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3163. }
  3164. TEST_F(NetworkContextTest, ResolveHost_DestroyContext) {
  3165. // Override the HostResolver with a hanging one, so the test can ensure the
  3166. // request won't be completed before the cancellation arrives.
  3167. auto resolver = std::make_unique<net::HangingHostResolver>();
  3168. scoped_refptr<const net::HangingHostResolver::State> state =
  3169. resolver->state();
  3170. network_service_->set_host_resolver_factory_for_testing(
  3171. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3172. std::unique_ptr<NetworkContext> network_context =
  3173. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3174. ASSERT_EQ(0, state->num_cancellations());
  3175. base::RunLoop run_loop;
  3176. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3177. mojom::ResolveHostParametersPtr optional_parameters =
  3178. mojom::ResolveHostParameters::New();
  3179. optional_parameters->control_handle =
  3180. control_handle.BindNewPipeAndPassReceiver();
  3181. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3182. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3183. network_context->ResolveHost(
  3184. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  3185. std::move(optional_parameters), std::move(pending_response_client));
  3186. bool control_handle_closed = false;
  3187. auto connection_error_callback =
  3188. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3189. control_handle.set_disconnect_handler(connection_error_callback);
  3190. network_context = nullptr;
  3191. run_loop.Run();
  3192. // On context destruction, should receive an ERR_FAILED result, and the
  3193. // internal resolver request should have been cancelled.
  3194. EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
  3195. EXPECT_FALSE(response_client.result_addresses());
  3196. EXPECT_EQ(1, state->num_cancellations());
  3197. EXPECT_TRUE(control_handle_closed);
  3198. }
  3199. TEST_F(NetworkContextTest, ResolveHost_CloseClient) {
  3200. // Override the HostResolver with a hanging one, so the test can ensure the
  3201. // request won't be completed before the cancellation arrives.
  3202. auto resolver = std::make_unique<net::HangingHostResolver>();
  3203. scoped_refptr<const net::HangingHostResolver::State> state =
  3204. resolver->state();
  3205. network_service_->set_host_resolver_factory_for_testing(
  3206. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3207. std::unique_ptr<NetworkContext> network_context =
  3208. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3209. ASSERT_EQ(0, state->num_cancellations());
  3210. base::RunLoop run_loop;
  3211. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3212. mojom::ResolveHostParametersPtr optional_parameters =
  3213. mojom::ResolveHostParameters::New();
  3214. optional_parameters->control_handle =
  3215. control_handle.BindNewPipeAndPassReceiver();
  3216. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3217. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3218. network_context->ResolveHost(
  3219. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  3220. std::move(optional_parameters), std::move(pending_response_client));
  3221. bool control_handle_closed = false;
  3222. auto connection_error_callback =
  3223. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3224. control_handle.set_disconnect_handler(connection_error_callback);
  3225. response_client.CloseReceiver();
  3226. run_loop.RunUntilIdle();
  3227. // Response pipe is closed, so no results to check. Internal request should be
  3228. // cancelled.
  3229. EXPECT_FALSE(response_client.complete());
  3230. EXPECT_EQ(1, state->num_cancellations());
  3231. EXPECT_TRUE(control_handle_closed);
  3232. EXPECT_EQ(0u,
  3233. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3234. }
  3235. // Test factory of net::HostResolvers. Creates standard (but potentially non-
  3236. // caching) net::ContextHostResolver. Keeps pointers to all created resolvers.
  3237. class TestResolverFactory : public net::HostResolver::Factory {
  3238. public:
  3239. static TestResolverFactory* CreateAndSetFactory(NetworkService* service) {
  3240. auto factory = std::make_unique<TestResolverFactory>();
  3241. auto* factory_ptr = factory.get();
  3242. service->set_host_resolver_factory_for_testing(std::move(factory));
  3243. return factory_ptr;
  3244. }
  3245. std::unique_ptr<net::HostResolver> CreateResolver(
  3246. net::HostResolverManager* manager,
  3247. base::StringPiece host_mapping_rules,
  3248. bool enable_caching) override {
  3249. DCHECK(host_mapping_rules.empty());
  3250. auto resolve_context = std::make_unique<net::ResolveContext>(
  3251. /*url_request_context=*/nullptr, /*enable_caching=*/false);
  3252. auto resolver = std::make_unique<net::ContextHostResolver>(
  3253. manager, std::move(resolve_context));
  3254. resolvers_.push_back(resolver.get());
  3255. return resolver;
  3256. }
  3257. std::unique_ptr<net::HostResolver> CreateStandaloneResolver(
  3258. net::NetLog* net_log,
  3259. const net::HostResolver::ManagerOptions& options,
  3260. base::StringPiece host_mapping_rules,
  3261. bool enable_caching) override {
  3262. DCHECK(host_mapping_rules.empty());
  3263. std::unique_ptr<net::ContextHostResolver> resolver =
  3264. net::HostResolver::CreateStandaloneContextResolver(net_log, options,
  3265. enable_caching);
  3266. resolvers_.push_back(resolver.get());
  3267. return resolver;
  3268. }
  3269. const std::vector<net::ContextHostResolver*>& resolvers() const {
  3270. return resolvers_;
  3271. }
  3272. void ForgetResolvers() { resolvers_.clear(); }
  3273. private:
  3274. std::vector<net::ContextHostResolver*> resolvers_;
  3275. };
  3276. TEST_F(NetworkContextTest, CreateHostResolver) {
  3277. // Inject a factory to control and capture created net::HostResolvers.
  3278. TestResolverFactory* factory =
  3279. TestResolverFactory::CreateAndSetFactory(network_service_.get());
  3280. std::unique_ptr<NetworkContext> network_context =
  3281. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3282. // Creates single shared (within the NetworkContext) internal HostResolver.
  3283. EXPECT_EQ(1u, factory->resolvers().size());
  3284. factory->ForgetResolvers();
  3285. mojo::Remote<mojom::HostResolver> resolver;
  3286. network_context->CreateHostResolver(absl::nullopt,
  3287. resolver.BindNewPipeAndPassReceiver());
  3288. // Expected to reuse shared (within the NetworkContext) internal HostResolver.
  3289. EXPECT_TRUE(factory->resolvers().empty());
  3290. base::RunLoop run_loop;
  3291. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3292. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3293. resolver->ResolveHost(net::HostPortPair("localhost", 80),
  3294. net::NetworkIsolationKey(), nullptr,
  3295. std::move(pending_response_client));
  3296. run_loop.Run();
  3297. EXPECT_EQ(net::OK, response_client.result_error());
  3298. EXPECT_THAT(
  3299. response_client.result_addresses().value().endpoints(),
  3300. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  3301. CreateExpectedEndPoint("::1", 80)));
  3302. EXPECT_EQ(0u,
  3303. network_context->GetNumOutstandingResolveHostRequestsForTesting());
  3304. }
  3305. TEST_F(NetworkContextTest, CreateHostResolver_CloseResolver) {
  3306. // Override the HostResolver with a hanging one, so the test can ensure the
  3307. // request won't be completed before the cancellation arrives.
  3308. auto resolver = std::make_unique<net::HangingHostResolver>();
  3309. scoped_refptr<const net::HangingHostResolver::State> state =
  3310. resolver->state();
  3311. network_service_->set_host_resolver_factory_for_testing(
  3312. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3313. std::unique_ptr<NetworkContext> network_context =
  3314. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3315. mojo::Remote<mojom::HostResolver> resolver_remote;
  3316. network_context->CreateHostResolver(
  3317. absl::nullopt, resolver_remote.BindNewPipeAndPassReceiver());
  3318. ASSERT_EQ(0, state->num_cancellations());
  3319. base::RunLoop run_loop;
  3320. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3321. mojom::ResolveHostParametersPtr optional_parameters =
  3322. mojom::ResolveHostParameters::New();
  3323. optional_parameters->control_handle =
  3324. control_handle.BindNewPipeAndPassReceiver();
  3325. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3326. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3327. resolver_remote->ResolveHost(
  3328. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  3329. std::move(optional_parameters), std::move(pending_response_client));
  3330. bool control_handle_closed = false;
  3331. auto connection_error_callback =
  3332. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3333. control_handle.set_disconnect_handler(connection_error_callback);
  3334. resolver_remote.reset();
  3335. run_loop.Run();
  3336. // On resolver destruction, should receive an ERR_FAILED result, and the
  3337. // internal resolver request should have been cancelled.
  3338. EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
  3339. EXPECT_FALSE(response_client.result_addresses());
  3340. EXPECT_EQ(1, state->num_cancellations());
  3341. EXPECT_TRUE(control_handle_closed);
  3342. }
  3343. TEST_F(NetworkContextTest, CreateHostResolver_CloseContext) {
  3344. // Override the HostResolver with a hanging one, so the test can ensure the
  3345. // request won't be completed before the cancellation arrives.
  3346. auto resolver = std::make_unique<net::HangingHostResolver>();
  3347. scoped_refptr<const net::HangingHostResolver::State> state =
  3348. resolver->state();
  3349. network_service_->set_host_resolver_factory_for_testing(
  3350. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3351. std::unique_ptr<NetworkContext> network_context =
  3352. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3353. mojo::Remote<mojom::HostResolver> resolver_remote;
  3354. network_context->CreateHostResolver(
  3355. absl::nullopt, resolver_remote.BindNewPipeAndPassReceiver());
  3356. ASSERT_EQ(0, state->num_cancellations());
  3357. base::RunLoop run_loop;
  3358. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  3359. mojom::ResolveHostParametersPtr optional_parameters =
  3360. mojom::ResolveHostParameters::New();
  3361. optional_parameters->control_handle =
  3362. control_handle.BindNewPipeAndPassReceiver();
  3363. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3364. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3365. resolver_remote->ResolveHost(
  3366. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  3367. std::move(optional_parameters), std::move(pending_response_client));
  3368. // Run a bit to ensure the resolve request makes it to the resolver. Otherwise
  3369. // the resolver will be destroyed and close its pipe before it even knows
  3370. // about the request to send a failure.
  3371. task_environment_.RunUntilIdle();
  3372. bool control_handle_closed = false;
  3373. auto connection_error_callback =
  3374. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  3375. control_handle.set_disconnect_handler(connection_error_callback);
  3376. bool resolver_closed = false;
  3377. auto resolver_closed_callback =
  3378. base::BindLambdaForTesting([&]() { resolver_closed = true; });
  3379. resolver_remote.set_disconnect_handler(resolver_closed_callback);
  3380. network_context = nullptr;
  3381. run_loop.Run();
  3382. // On context destruction, should receive an ERR_FAILED result, and the
  3383. // internal resolver request should have been cancelled.
  3384. EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
  3385. EXPECT_FALSE(response_client.result_addresses());
  3386. EXPECT_EQ(1, state->num_cancellations());
  3387. EXPECT_TRUE(control_handle_closed);
  3388. EXPECT_TRUE(resolver_closed);
  3389. }
  3390. // Config overrides are not supported on iOS.
  3391. #if !BUILDFLAG(IS_IOS)
  3392. TEST_F(NetworkContextTest, CreateHostResolverWithConfigOverrides) {
  3393. // Inject a factory to control and capture created net::HostResolvers.
  3394. TestResolverFactory* factory =
  3395. TestResolverFactory::CreateAndSetFactory(network_service_.get());
  3396. std::unique_ptr<NetworkContext> network_context =
  3397. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3398. // Creates single shared (within the NetworkContext) internal HostResolver.
  3399. EXPECT_EQ(1u, factory->resolvers().size());
  3400. factory->ForgetResolvers();
  3401. net::DnsConfigOverrides overrides;
  3402. overrides.nameservers = std::vector<net::IPEndPoint>{
  3403. CreateExpectedEndPoint("100.100.100.100", 22)};
  3404. mojo::Remote<mojom::HostResolver> resolver;
  3405. network_context->CreateHostResolver(overrides,
  3406. resolver.BindNewPipeAndPassReceiver());
  3407. // Should create 1 private resolver with a DnsClient (if DnsClient is
  3408. // enablable for the build config).
  3409. ASSERT_EQ(1u, factory->resolvers().size());
  3410. net::ContextHostResolver* internal_resolver = factory->resolvers().front();
  3411. EXPECT_TRUE(internal_resolver->GetDnsConfigAsValue().is_dict());
  3412. // Override DnsClient with a basic mock.
  3413. net::DnsConfig base_configuration;
  3414. base_configuration.nameservers = {CreateExpectedEndPoint("12.12.12.12", 53)};
  3415. const std::string kQueryHostname = "example.com";
  3416. const std::string kResult = "1.2.3.4";
  3417. net::IPAddress result;
  3418. CHECK(result.AssignFromIPLiteral(kResult));
  3419. net::MockDnsClientRuleList rules;
  3420. rules.emplace_back(
  3421. kQueryHostname, net::dns_protocol::kTypeA, false /* secure */,
  3422. net::MockDnsClientRule::Result(
  3423. net::BuildTestDnsAddressResponse(kQueryHostname, result)),
  3424. false /* delay */);
  3425. rules.emplace_back(kQueryHostname, net::dns_protocol::kTypeAAAA,
  3426. false /* secure */,
  3427. net::MockDnsClientRule::Result(
  3428. net::MockDnsClientRule::ResultType::kEmpty),
  3429. false /* delay */);
  3430. auto mock_dns_client = std::make_unique<net::MockDnsClient>(
  3431. base_configuration, std::move(rules));
  3432. mock_dns_client->SetInsecureEnabled(/*enabled=*/true,
  3433. /*additional_types_enabled=*/false);
  3434. mock_dns_client->set_ignore_system_config_changes(true);
  3435. auto* mock_dns_client_ptr = mock_dns_client.get();
  3436. internal_resolver->GetManagerForTesting()->SetDnsClientForTesting(
  3437. std::move(mock_dns_client));
  3438. // Test that the DnsClient is getting the overridden configuration.
  3439. EXPECT_TRUE(overrides.ApplyOverrides(base_configuration)
  3440. .Equals(*mock_dns_client_ptr->GetEffectiveConfig()));
  3441. // Ensure we are using the private resolver by testing that we get results
  3442. // from the overridden DnsClient.
  3443. base::RunLoop run_loop;
  3444. mojom::ResolveHostParametersPtr optional_parameters =
  3445. mojom::ResolveHostParameters::New();
  3446. optional_parameters->dns_query_type = net::DnsQueryType::A;
  3447. optional_parameters->source = net::HostResolverSource::DNS;
  3448. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  3449. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  3450. resolver->ResolveHost(
  3451. net::HostPortPair(kQueryHostname, 80), net::NetworkIsolationKey(),
  3452. std::move(optional_parameters), std::move(pending_response_client));
  3453. run_loop.Run();
  3454. EXPECT_EQ(net::OK, response_client.result_error());
  3455. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  3456. testing::ElementsAre(CreateExpectedEndPoint(kResult, 80)));
  3457. }
  3458. #endif // BUILDFLAG(IS_IOS)
  3459. TEST_F(NetworkContextTest, ActivateDohProbes) {
  3460. auto resolver = std::make_unique<net::MockHostResolver>();
  3461. scoped_refptr<const net::MockHostResolver::State> state = resolver->state();
  3462. network_service_->set_host_resolver_factory_for_testing(
  3463. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3464. mojom::NetworkContextParamsPtr params =
  3465. CreateNetworkContextParamsForTesting();
  3466. std::unique_ptr<NetworkContext> network_context =
  3467. CreateContextWithParams(std::move(params));
  3468. ASSERT_FALSE(state->IsDohProbeRunning());
  3469. network_context->ActivateDohProbes();
  3470. EXPECT_TRUE(state->IsDohProbeRunning());
  3471. base::RunLoop().RunUntilIdle();
  3472. EXPECT_TRUE(state->IsDohProbeRunning());
  3473. network_context.reset();
  3474. EXPECT_FALSE(state->IsDohProbeRunning());
  3475. }
  3476. TEST_F(NetworkContextTest, ActivateDohProbes_NotPrimaryContext) {
  3477. auto resolver = std::make_unique<net::MockHostResolver>();
  3478. scoped_refptr<const net::MockHostResolver::State> state = resolver->state();
  3479. network_service_->set_host_resolver_factory_for_testing(
  3480. std::make_unique<HostResolverFactory>(std::move(resolver)));
  3481. std::unique_ptr<NetworkContext> network_context =
  3482. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3483. ASSERT_FALSE(state->IsDohProbeRunning());
  3484. network_context->ActivateDohProbes();
  3485. EXPECT_TRUE(state->IsDohProbeRunning());
  3486. base::RunLoop().RunUntilIdle();
  3487. EXPECT_TRUE(state->IsDohProbeRunning());
  3488. network_context.reset();
  3489. EXPECT_FALSE(state->IsDohProbeRunning());
  3490. }
  3491. TEST_F(NetworkContextTest, PrivacyModeDisabledByDefault) {
  3492. const GURL kOtherURL("http://other.com");
  3493. std::unique_ptr<NetworkContext> network_context =
  3494. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3495. EXPECT_EQ(net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3496. network_context->url_request_context()
  3497. ->network_delegate()
  3498. ->ForcePrivacyMode(GURL("http://foo.com"),
  3499. net::SiteForCookies::FromUrl(kOtherURL),
  3500. url::Origin::Create(kOtherURL),
  3501. net::SamePartyContext::Type::kCrossParty));
  3502. }
  3503. TEST_F(NetworkContextTest, PrivacyModeEnabledIfCookiesBlocked) {
  3504. const GURL kURL("http://foo.com");
  3505. const GURL kOtherURL("http://other.com");
  3506. std::unique_ptr<NetworkContext> network_context =
  3507. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3508. SetContentSetting(kURL, kOtherURL, CONTENT_SETTING_BLOCK,
  3509. network_context.get());
  3510. EXPECT_EQ(
  3511. net::NetworkDelegate::PrivacySetting::kStateDisallowed,
  3512. network_context->url_request_context()
  3513. ->network_delegate()
  3514. ->ForcePrivacyMode(kURL, net::SiteForCookies::FromUrl(kOtherURL),
  3515. url::Origin::Create(kOtherURL),
  3516. net::SamePartyContext::Type::kCrossParty));
  3517. EXPECT_EQ(
  3518. net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3519. network_context->url_request_context()
  3520. ->network_delegate()
  3521. ->ForcePrivacyMode(kOtherURL, net::SiteForCookies::FromUrl(kURL),
  3522. url::Origin::Create(kURL),
  3523. net::SamePartyContext::Type::kCrossParty));
  3524. }
  3525. TEST_F(NetworkContextTest, PrivacyModeDisabledIfCookiesAllowed) {
  3526. const GURL kURL("http://foo.com");
  3527. const GURL kOtherURL("http://other.com");
  3528. std::unique_ptr<NetworkContext> network_context =
  3529. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3530. SetContentSetting(kURL, kOtherURL, CONTENT_SETTING_ALLOW,
  3531. network_context.get());
  3532. EXPECT_EQ(
  3533. net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3534. network_context->url_request_context()
  3535. ->network_delegate()
  3536. ->ForcePrivacyMode(kURL, net::SiteForCookies::FromUrl(kOtherURL),
  3537. url::Origin::Create(kOtherURL),
  3538. net::SamePartyContext::Type::kCrossParty));
  3539. }
  3540. TEST_F(NetworkContextTest, PrivacyModeDisabledIfCookiesSettingForOtherURL) {
  3541. const GURL kURL("http://foo.com");
  3542. const GURL kOtherURL("http://other.com");
  3543. std::unique_ptr<NetworkContext> network_context =
  3544. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3545. // URLs are switched so setting should not apply.
  3546. SetContentSetting(kOtherURL, kURL, CONTENT_SETTING_BLOCK,
  3547. network_context.get());
  3548. EXPECT_EQ(
  3549. net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3550. network_context->url_request_context()
  3551. ->network_delegate()
  3552. ->ForcePrivacyMode(kURL, net::SiteForCookies::FromUrl(kOtherURL),
  3553. url::Origin::Create(kOtherURL),
  3554. net::SamePartyContext::Type::kCrossParty));
  3555. }
  3556. TEST_F(NetworkContextTest, PrivacyModeEnabledIfThirdPartyCookiesBlocked) {
  3557. const GURL kURL("http://foo.com");
  3558. const url::Origin kOrigin = url::Origin::Create(kURL);
  3559. const GURL kOtherURL("http://other.com");
  3560. const url::Origin kOtherOrigin = url::Origin::Create(kOtherURL);
  3561. std::unique_ptr<NetworkContext> network_context =
  3562. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3563. net::NetworkDelegate* delegate =
  3564. network_context->url_request_context()->network_delegate();
  3565. network_context->cookie_manager()->BlockThirdPartyCookies(true);
  3566. EXPECT_EQ(net::NetworkDelegate::PrivacySetting::kPartitionedStateAllowedOnly,
  3567. delegate->ForcePrivacyMode(
  3568. kURL, net::SiteForCookies::FromUrl(kOtherURL), kOtherOrigin,
  3569. net::SamePartyContext::Type::kCrossParty));
  3570. EXPECT_EQ(net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3571. delegate->ForcePrivacyMode(
  3572. kURL, net::SiteForCookies::FromUrl(kURL), kOrigin,
  3573. net::SamePartyContext::Type::kSameParty));
  3574. network_context->cookie_manager()->BlockThirdPartyCookies(false);
  3575. EXPECT_EQ(net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3576. delegate->ForcePrivacyMode(
  3577. kURL, net::SiteForCookies::FromUrl(kOtherURL), kOtherOrigin,
  3578. net::SamePartyContext::Type::kCrossParty));
  3579. EXPECT_EQ(net::NetworkDelegate::PrivacySetting::kStateAllowed,
  3580. delegate->ForcePrivacyMode(
  3581. kURL, net::SiteForCookies::FromUrl(kURL), kOrigin,
  3582. net::SamePartyContext::Type::kSameParty));
  3583. }
  3584. TEST_F(NetworkContextTest, CanSetCookieFalseIfCookiesBlocked) {
  3585. std::unique_ptr<NetworkContext> network_context =
  3586. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3587. auto context = CreateTestURLRequestContextBuilder()->Build();
  3588. std::unique_ptr<net::URLRequest> request =
  3589. context->CreateRequest(GURL("http://foo.com"), net::DEFAULT_PRIORITY,
  3590. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  3591. auto cookie = net::CanonicalCookie::CreateUnsafeCookieForTesting(
  3592. "TestCookie", "1", "www.test.com", "/", base::Time(), base::Time(),
  3593. base::Time(), base::Time(), false, false, net::CookieSameSite::LAX_MODE,
  3594. net::COOKIE_PRIORITY_LOW, false);
  3595. EXPECT_TRUE(
  3596. network_context->url_request_context()->network_delegate()->CanSetCookie(
  3597. *request, *cookie, nullptr));
  3598. SetDefaultContentSetting(CONTENT_SETTING_BLOCK, network_context.get());
  3599. EXPECT_FALSE(
  3600. network_context->url_request_context()->network_delegate()->CanSetCookie(
  3601. *request, *cookie, nullptr));
  3602. }
  3603. TEST_F(NetworkContextTest, CanSetCookieTrueIfCookiesAllowed) {
  3604. std::unique_ptr<NetworkContext> network_context =
  3605. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3606. auto context = CreateTestURLRequestContextBuilder()->Build();
  3607. std::unique_ptr<net::URLRequest> request =
  3608. context->CreateRequest(GURL("http://foo.com"), net::DEFAULT_PRIORITY,
  3609. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  3610. auto cookie = net::CanonicalCookie::CreateUnsafeCookieForTesting(
  3611. "TestCookie", "1", "www.test.com", "/", base::Time(), base::Time(),
  3612. base::Time(), base::Time(), false, false, net::CookieSameSite::LAX_MODE,
  3613. net::COOKIE_PRIORITY_LOW, false);
  3614. SetDefaultContentSetting(CONTENT_SETTING_ALLOW, network_context.get());
  3615. EXPECT_TRUE(
  3616. network_context->url_request_context()->network_delegate()->CanSetCookie(
  3617. *request, *cookie, nullptr));
  3618. }
  3619. TEST_F(NetworkContextTest,
  3620. AnnotateAndMoveUserBlockedCookies_FalseIfCookiesBlocked) {
  3621. std::unique_ptr<NetworkContext> network_context =
  3622. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3623. auto context = CreateTestURLRequestContextBuilder()->Build();
  3624. std::unique_ptr<net::URLRequest> request =
  3625. context->CreateRequest(GURL("http://foo.com"), net::DEFAULT_PRIORITY,
  3626. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  3627. net::CookieAccessResultList included;
  3628. net::CookieAccessResultList excluded;
  3629. EXPECT_TRUE(
  3630. network_context->url_request_context()
  3631. ->network_delegate()
  3632. ->AnnotateAndMoveUserBlockedCookies(*request, included, excluded));
  3633. SetDefaultContentSetting(CONTENT_SETTING_BLOCK, network_context.get());
  3634. EXPECT_FALSE(
  3635. network_context->url_request_context()
  3636. ->network_delegate()
  3637. ->AnnotateAndMoveUserBlockedCookies(*request, included, excluded));
  3638. }
  3639. TEST_F(NetworkContextTest,
  3640. AnnotateAndMoveUserBlockedCookies_TrueIfCookiesAllowed) {
  3641. std::unique_ptr<NetworkContext> network_context =
  3642. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3643. auto context = CreateTestURLRequestContextBuilder()->Build();
  3644. std::unique_ptr<net::URLRequest> request =
  3645. context->CreateRequest(GURL("http://foo.com"), net::DEFAULT_PRIORITY,
  3646. nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
  3647. net::CookieAccessResultList included;
  3648. net::CookieAccessResultList excluded;
  3649. SetDefaultContentSetting(CONTENT_SETTING_ALLOW, network_context.get());
  3650. EXPECT_TRUE(
  3651. network_context->url_request_context()
  3652. ->network_delegate()
  3653. ->AnnotateAndMoveUserBlockedCookies(*request, included, excluded));
  3654. }
  3655. // Gets notified by the EmbeddedTestServer on incoming connections being
  3656. // accepted or read from, keeps track of them and exposes that info to
  3657. // the tests.
  3658. // A port being reused is currently considered an error. If a test
  3659. // needs to verify multiple connections are opened in sequence, that will need
  3660. // to be changed.
  3661. class ConnectionListener
  3662. : public net::test_server::EmbeddedTestServerConnectionListener {
  3663. public:
  3664. ConnectionListener() = default;
  3665. ConnectionListener(const ConnectionListener&) = delete;
  3666. ConnectionListener& operator=(const ConnectionListener&) = delete;
  3667. ~ConnectionListener() override = default;
  3668. // Get called from the EmbeddedTestServer thread to be notified that
  3669. // a connection was accepted.
  3670. std::unique_ptr<net::StreamSocket> AcceptedSocket(
  3671. std::unique_ptr<net::StreamSocket> connection) override {
  3672. base::AutoLock lock(lock_);
  3673. uint16_t socket = GetPort(*connection);
  3674. EXPECT_TRUE(sockets_.find(socket) == sockets_.end());
  3675. sockets_[socket] = SOCKET_ACCEPTED;
  3676. total_sockets_seen_++;
  3677. CheckAccepted();
  3678. return connection;
  3679. }
  3680. // Get called from the EmbeddedTestServer thread to be notified that
  3681. // a connection was read from.
  3682. void ReadFromSocket(const net::StreamSocket& connection, int rv) override {
  3683. EXPECT_GE(rv, net::OK);
  3684. }
  3685. // Wait for exactly |n| items in |sockets_|. |n| must be greater than 0.
  3686. void WaitForAcceptedConnections(size_t num_connections) {
  3687. DCHECK(on_done_accepting_connections_.is_null());
  3688. DCHECK_GT(num_connections, 0u);
  3689. base::RunLoop run_loop;
  3690. {
  3691. base::AutoLock lock(lock_);
  3692. EXPECT_GE(num_connections, sockets_.size() - total_sockets_waited_for_);
  3693. // QuitWhenIdle() instead of regular Quit() because in Preconnect tests we
  3694. // count "idle_socket_count" but tasks posted synchronously after
  3695. // AcceptedSocket() need to resolve before the new sockets are considered
  3696. // idle.
  3697. on_done_accepting_connections_ = run_loop.QuitWhenIdleClosure();
  3698. num_accepted_connections_needed_ = num_connections;
  3699. CheckAccepted();
  3700. }
  3701. // Note that the previous call to CheckAccepted can quit this run loop
  3702. // before this call, which will make this call a no-op.
  3703. run_loop.Run();
  3704. // Grab the mutex again and make sure that the number of accepted sockets is
  3705. // indeed |num_connections|.
  3706. base::AutoLock lock(lock_);
  3707. total_sockets_waited_for_ += num_connections;
  3708. EXPECT_EQ(total_sockets_seen_, total_sockets_waited_for_);
  3709. }
  3710. // Helper function to stop the waiting for sockets to be accepted for
  3711. // WaitForAcceptedConnections. |num_accepted_connections_loop_| spins
  3712. // until |num_accepted_connections_needed_| sockets are accepted by the test
  3713. // server. The values will be null/0 if the loop is not running.
  3714. void CheckAccepted() {
  3715. lock_.AssertAcquired();
  3716. // |num_accepted_connections_loop_| null implies
  3717. // |num_accepted_connections_needed_| == 0.
  3718. DCHECK(!on_done_accepting_connections_.is_null() ||
  3719. num_accepted_connections_needed_ == 0);
  3720. if (on_done_accepting_connections_.is_null() ||
  3721. num_accepted_connections_needed_ !=
  3722. sockets_.size() - total_sockets_waited_for_) {
  3723. return;
  3724. }
  3725. num_accepted_connections_needed_ = 0;
  3726. std::move(on_done_accepting_connections_).Run();
  3727. }
  3728. int GetTotalSocketsSeen() const {
  3729. base::AutoLock lock(lock_);
  3730. return total_sockets_seen_;
  3731. }
  3732. private:
  3733. static uint16_t GetPort(const net::StreamSocket& connection) {
  3734. // Get the remote port of the peer, since the local port will always be the
  3735. // port the test server is listening on. This isn't strictly correct - it's
  3736. // possible for multiple peers to connect with the same remote port but
  3737. // different remote IPs - but the tests here assume that connections to the
  3738. // test server (running on localhost) will always come from localhost, and
  3739. // thus the peer port is all thats needed to distinguish two connections.
  3740. // This also would be problematic if the OS reused ports, but that's not
  3741. // something to worry about for these tests.
  3742. net::IPEndPoint address;
  3743. EXPECT_EQ(net::OK, connection.GetPeerAddress(&address));
  3744. return address.port();
  3745. }
  3746. int total_sockets_seen_ = 0;
  3747. int total_sockets_waited_for_ = 0;
  3748. enum SocketStatus { SOCKET_ACCEPTED, SOCKET_READ_FROM };
  3749. // This lock protects all the members below, which each are used on both the
  3750. // IO and UI thread. Members declared after the lock are protected by it.
  3751. mutable base::Lock lock_;
  3752. typedef std::map<uint16_t, SocketStatus> SocketContainer;
  3753. SocketContainer sockets_;
  3754. // If |num_accepted_connections_needed_| is non zero, then the object is
  3755. // waiting for |num_accepted_connections_needed_| sockets to be accepted
  3756. // before invoking |on_done_accepting_connections_|.
  3757. size_t num_accepted_connections_needed_ = 0;
  3758. base::OnceClosure on_done_accepting_connections_;
  3759. };
  3760. TEST_F(NetworkContextTest, PreconnectOne) {
  3761. std::unique_ptr<NetworkContext> network_context =
  3762. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3763. ConnectionListener connection_listener;
  3764. net::EmbeddedTestServer test_server;
  3765. test_server.SetConnectionListener(&connection_listener);
  3766. ASSERT_TRUE(test_server.Start());
  3767. network_context->PreconnectSockets(1, test_server.base_url(),
  3768. /*allow_credentials=*/true,
  3769. net::NetworkIsolationKey());
  3770. connection_listener.WaitForAcceptedConnections(1u);
  3771. }
  3772. TEST_F(NetworkContextTest, PreconnectHSTS) {
  3773. net::NetworkIsolationKey network_isolation_key =
  3774. net::NetworkIsolationKey::CreateTransient();
  3775. for (bool partition_connections : {false, true}) {
  3776. base::test::ScopedFeatureList feature_list;
  3777. if (partition_connections) {
  3778. feature_list.InitAndEnableFeature(
  3779. net::features::kPartitionConnectionsByNetworkIsolationKey);
  3780. } else {
  3781. feature_list.InitAndDisableFeature(
  3782. net::features::kPartitionConnectionsByNetworkIsolationKey);
  3783. }
  3784. std::unique_ptr<NetworkContext> network_context =
  3785. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3786. ConnectionListener connection_listener;
  3787. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  3788. test_server.SetConnectionListener(&connection_listener);
  3789. ASSERT_TRUE(test_server.Start());
  3790. ASSERT_TRUE(test_server.base_url().SchemeIs(url::kHttpsScheme));
  3791. net::ClientSocketPool::GroupId ssl_group(
  3792. url::SchemeHostPort(test_server.base_url()),
  3793. net::PrivacyMode::PRIVACY_MODE_ENABLED,
  3794. partition_connections ? network_isolation_key
  3795. : net::NetworkIsolationKey(),
  3796. net::SecureDnsPolicy::kAllow);
  3797. const GURL server_http_url = GetHttpUrlFromHttps(test_server.base_url());
  3798. ASSERT_TRUE(server_http_url.SchemeIs(url::kHttpScheme));
  3799. net::ClientSocketPool::GroupId group(url::SchemeHostPort(server_http_url),
  3800. net::PrivacyMode::PRIVACY_MODE_ENABLED,
  3801. partition_connections
  3802. ? network_isolation_key
  3803. : net::NetworkIsolationKey(),
  3804. net::SecureDnsPolicy::kAllow);
  3805. network_context->PreconnectSockets(1, server_http_url,
  3806. /*allow_credentials=*/false,
  3807. network_isolation_key);
  3808. connection_listener.WaitForAcceptedConnections(1u);
  3809. int num_sockets = GetSocketCountForGroup(network_context.get(), group);
  3810. EXPECT_EQ(num_sockets, 1);
  3811. const base::Time expiry = base::Time::Now() + base::Seconds(1000);
  3812. network_context->url_request_context()->transport_security_state()->AddHSTS(
  3813. server_http_url.host(), expiry, false);
  3814. network_context->PreconnectSockets(1, server_http_url,
  3815. /*allow_credentials=*/false,
  3816. network_isolation_key);
  3817. connection_listener.WaitForAcceptedConnections(1u);
  3818. // If HSTS weren't respected, the initial connection would have been reused.
  3819. num_sockets = GetSocketCountForGroup(network_context.get(), ssl_group);
  3820. EXPECT_EQ(num_sockets, 1);
  3821. }
  3822. }
  3823. TEST_F(NetworkContextTest, PreconnectZero) {
  3824. std::unique_ptr<NetworkContext> network_context =
  3825. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3826. ConnectionListener connection_listener;
  3827. net::EmbeddedTestServer test_server;
  3828. test_server.SetConnectionListener(&connection_listener);
  3829. ASSERT_TRUE(test_server.Start());
  3830. network_context->PreconnectSockets(0, test_server.base_url(),
  3831. /*allow_credentials=*/true,
  3832. net::NetworkIsolationKey());
  3833. base::RunLoop().RunUntilIdle();
  3834. int num_sockets =
  3835. GetSocketPoolInfo(network_context.get(), "idle_socket_count");
  3836. ASSERT_EQ(num_sockets, 0);
  3837. int num_connecting_sockets =
  3838. GetSocketPoolInfo(network_context.get(), "connecting_socket_count");
  3839. ASSERT_EQ(num_connecting_sockets, 0);
  3840. }
  3841. TEST_F(NetworkContextTest, PreconnectTwo) {
  3842. std::unique_ptr<NetworkContext> network_context =
  3843. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3844. ConnectionListener connection_listener;
  3845. net::EmbeddedTestServer test_server;
  3846. test_server.SetConnectionListener(&connection_listener);
  3847. ASSERT_TRUE(test_server.Start());
  3848. network_context->PreconnectSockets(2, test_server.base_url(),
  3849. /*allow_credentials=*/true,
  3850. net::NetworkIsolationKey());
  3851. connection_listener.WaitForAcceptedConnections(2u);
  3852. int num_sockets =
  3853. GetSocketPoolInfo(network_context.get(), "idle_socket_count");
  3854. ASSERT_EQ(num_sockets, 2);
  3855. }
  3856. TEST_F(NetworkContextTest, PreconnectFour) {
  3857. std::unique_ptr<NetworkContext> network_context =
  3858. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3859. ConnectionListener connection_listener;
  3860. net::EmbeddedTestServer test_server;
  3861. test_server.SetConnectionListener(&connection_listener);
  3862. ASSERT_TRUE(test_server.Start());
  3863. network_context->PreconnectSockets(4, test_server.base_url(),
  3864. /*allow_credentials=*/true,
  3865. net::NetworkIsolationKey());
  3866. connection_listener.WaitForAcceptedConnections(4u);
  3867. int num_sockets =
  3868. GetSocketPoolInfo(network_context.get(), "idle_socket_count");
  3869. ASSERT_EQ(num_sockets, 4);
  3870. }
  3871. TEST_F(NetworkContextTest, PreconnectMax) {
  3872. std::unique_ptr<NetworkContext> network_context =
  3873. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3874. ConnectionListener connection_listener;
  3875. net::EmbeddedTestServer test_server;
  3876. test_server.SetConnectionListener(&connection_listener);
  3877. ASSERT_TRUE(test_server.Start());
  3878. int max_num_sockets =
  3879. GetSocketPoolInfo(network_context.get(), "max_sockets_per_group");
  3880. EXPECT_GT(76, max_num_sockets);
  3881. network_context->PreconnectSockets(76, test_server.base_url(),
  3882. /*allow_credentials=*/true,
  3883. net::NetworkIsolationKey());
  3884. // Wait until |max_num_sockets| have been connected.
  3885. connection_listener.WaitForAcceptedConnections(max_num_sockets);
  3886. // This is not guaranteed to wait long enough if more than |max_num_sockets|
  3887. // connections are actually made, but experimentally, it fails consistently if
  3888. // that's the case.
  3889. base::RunLoop().RunUntilIdle();
  3890. int num_sockets =
  3891. GetSocketPoolInfo(network_context.get(), "idle_socket_count");
  3892. ASSERT_EQ(num_sockets, max_num_sockets);
  3893. }
  3894. // Make sure preconnects for the same URL but with different network isolation
  3895. // keys are not merged.
  3896. TEST_F(NetworkContextTest, PreconnectNetworkIsolationKey) {
  3897. base::test::ScopedFeatureList feature_list;
  3898. feature_list.InitAndEnableFeature(
  3899. net::features::kPartitionConnectionsByNetworkIsolationKey);
  3900. std::unique_ptr<NetworkContext> network_context =
  3901. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3902. ConnectionListener connection_listener;
  3903. net::EmbeddedTestServer test_server;
  3904. test_server.SetConnectionListener(&connection_listener);
  3905. ASSERT_TRUE(test_server.Start());
  3906. const auto kOriginFoo = url::Origin::Create(GURL("http://foo.test"));
  3907. const auto kOriginBar = url::Origin::Create(GURL("http://bar.test"));
  3908. const net::NetworkIsolationKey kKey1(kOriginFoo, kOriginFoo);
  3909. const net::NetworkIsolationKey kKey2(kOriginBar, kOriginBar);
  3910. network_context->PreconnectSockets(1, test_server.base_url(),
  3911. /*allow_credentials=*/false, kKey1);
  3912. network_context->PreconnectSockets(2, test_server.base_url(),
  3913. /*allow_credentials=*/false, kKey2);
  3914. connection_listener.WaitForAcceptedConnections(3u);
  3915. url::SchemeHostPort destination(test_server.base_url());
  3916. net::ClientSocketPool::GroupId group_id1(
  3917. destination, net::PrivacyMode::PRIVACY_MODE_ENABLED, kKey1,
  3918. net::SecureDnsPolicy::kAllow);
  3919. EXPECT_EQ(1, GetSocketCountForGroup(network_context.get(), group_id1));
  3920. net::ClientSocketPool::GroupId group_id2(
  3921. destination, net::PrivacyMode::PRIVACY_MODE_ENABLED, kKey2,
  3922. net::SecureDnsPolicy::kAllow);
  3923. EXPECT_EQ(2, GetSocketCountForGroup(network_context.get(), group_id2));
  3924. }
  3925. // This tests both ClostAllConnetions and CloseIdleConnections.
  3926. TEST_F(NetworkContextTest, CloseConnections) {
  3927. // Have to close all connections first, as CloseIdleConnections leaves around
  3928. // a connection at the end of the test.
  3929. for (bool close_all_connections : {true, false}) {
  3930. std::unique_ptr<NetworkContext> network_context =
  3931. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  3932. // Use different paths to avoid running into the cache lock.
  3933. const char kPath1[] = "/foo";
  3934. const char kPath2[] = "/bar";
  3935. const char kPath3[] = "/baz";
  3936. net::EmbeddedTestServer test_server;
  3937. net::test_server::ControllableHttpResponse controllable_response1(
  3938. &test_server, kPath1);
  3939. net::test_server::ControllableHttpResponse controllable_response2(
  3940. &test_server, kPath2);
  3941. net::test_server::ControllableHttpResponse controllable_response3(
  3942. &test_server, kPath3);
  3943. ASSERT_TRUE(test_server.Start());
  3944. // Start three network requests. Requests have to all be started before any
  3945. // one of them receives a response to be sure none of them tries to reuse
  3946. // the socket created by another one.
  3947. net::TestDelegate delegate1;
  3948. base::RunLoop run_loop1;
  3949. delegate1.set_on_complete(run_loop1.QuitClosure());
  3950. std::unique_ptr<net::URLRequest> request1 =
  3951. network_context->url_request_context()->CreateRequest(
  3952. test_server.GetURL(kPath1), net::DEFAULT_PRIORITY, &delegate1,
  3953. TRAFFIC_ANNOTATION_FOR_TESTS);
  3954. request1->Start();
  3955. controllable_response1.WaitForRequest();
  3956. EXPECT_EQ(
  3957. 1, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  3958. net::TestDelegate delegate2;
  3959. base::RunLoop run_loop2;
  3960. delegate2.set_on_complete(run_loop2.QuitClosure());
  3961. std::unique_ptr<net::URLRequest> request2 =
  3962. network_context->url_request_context()->CreateRequest(
  3963. test_server.GetURL(kPath2), net::DEFAULT_PRIORITY, &delegate2,
  3964. TRAFFIC_ANNOTATION_FOR_TESTS);
  3965. request2->Start();
  3966. controllable_response2.WaitForRequest();
  3967. EXPECT_EQ(
  3968. 2, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  3969. net::TestDelegate delegate3;
  3970. base::RunLoop run_loop3;
  3971. delegate3.set_on_complete(run_loop3.QuitClosure());
  3972. std::unique_ptr<net::URLRequest> request3 =
  3973. network_context->url_request_context()->CreateRequest(
  3974. test_server.GetURL(kPath3), net::DEFAULT_PRIORITY, &delegate3,
  3975. TRAFFIC_ANNOTATION_FOR_TESTS);
  3976. request3->Start();
  3977. controllable_response3.WaitForRequest();
  3978. EXPECT_EQ(
  3979. 3, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  3980. // Complete the first two requests successfully, with a keep-alive response.
  3981. // The EmbeddedTestServer doesn't actually support connection reuse, but
  3982. // this will send a raw response that will make the network stack think it
  3983. // does, and will cause the connection not to be closed.
  3984. controllable_response1.Send(
  3985. "HTTP/1.1 200 OK\r\n"
  3986. "Connection: keep-alive\r\n"
  3987. "Content-Length: 0\r\n\r\n");
  3988. controllable_response2.Send(
  3989. "HTTP/1.1 200 OK\r\n"
  3990. "Connection: keep-alive\r\n"
  3991. "Content-Length: 0\r\n\r\n");
  3992. run_loop1.Run();
  3993. run_loop2.Run();
  3994. // There should now be 2 idle and one handed out socket.
  3995. EXPECT_EQ(2, GetSocketPoolInfo(network_context.get(), "idle_socket_count"));
  3996. EXPECT_EQ(
  3997. 1, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  3998. // Closing all or idle connections should result in closing the idle
  3999. // sockets, but the handed out socket can't be closed.
  4000. base::RunLoop run_loop;
  4001. if (close_all_connections) {
  4002. network_context->CloseAllConnections(run_loop.QuitClosure());
  4003. } else {
  4004. network_context->CloseIdleConnections(run_loop.QuitClosure());
  4005. }
  4006. run_loop.Run();
  4007. EXPECT_EQ(0, GetSocketPoolInfo(network_context.get(), "idle_socket_count"));
  4008. EXPECT_EQ(
  4009. 1, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  4010. // The final request completes. In the close all connections case, its
  4011. // socket should be closed as soon as it is returned to the pool, but in the
  4012. // CloseIdleConnections case, it is added to the pool as an idle socket.
  4013. controllable_response3.Send(
  4014. "HTTP/1.1 200 OK\r\n"
  4015. "Connection: keep-alive\r\n"
  4016. "Content-Length: 0\r\n\r\n");
  4017. run_loop3.Run();
  4018. EXPECT_EQ(close_all_connections ? 0 : 1,
  4019. GetSocketPoolInfo(network_context.get(), "idle_socket_count"));
  4020. EXPECT_EQ(
  4021. 0, GetSocketPoolInfo(network_context.get(), "handed_out_socket_count"));
  4022. }
  4023. }
  4024. // Test that only trusted URLLoaderFactories accept
  4025. // ResourceRequest::trusted_params.
  4026. TEST_F(NetworkContextTest, TrustedParams) {
  4027. for (bool trusted_factory : {false, true}) {
  4028. ConnectionListener connection_listener;
  4029. net::EmbeddedTestServer test_server;
  4030. test_server.AddDefaultHandlers(
  4031. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4032. test_server.SetConnectionListener(&connection_listener);
  4033. ASSERT_TRUE(test_server.Start());
  4034. std::unique_ptr<NetworkContext> network_context =
  4035. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4036. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4037. mojom::URLLoaderFactoryParamsPtr params =
  4038. mojom::URLLoaderFactoryParams::New();
  4039. params->process_id = mojom::kBrowserProcessId;
  4040. params->is_corb_enabled = false;
  4041. // URLLoaderFactories should not be trusted by default.
  4042. EXPECT_FALSE(params->is_trusted);
  4043. params->is_trusted = trusted_factory;
  4044. network_context->CreateURLLoaderFactory(
  4045. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4046. ResourceRequest request;
  4047. request.url = test_server.GetURL("/echo");
  4048. request.trusted_params = ResourceRequest::TrustedParams();
  4049. mojo::PendingRemote<mojom::URLLoader> loader;
  4050. TestURLLoaderClient client;
  4051. loader_factory->CreateLoaderAndStart(
  4052. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4053. 0 /* options */, request, client.CreateRemote(),
  4054. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4055. client.RunUntilComplete();
  4056. // If the factory was trusted, the request should have succeeded. Otherwise,
  4057. // it should have failed.
  4058. EXPECT_EQ(trusted_factory, client.has_received_response());
  4059. if (trusted_factory) {
  4060. EXPECT_THAT(client.completion_status().error_code, net::test::IsOk());
  4061. EXPECT_EQ(1, connection_listener.GetTotalSocketsSeen());
  4062. } else {
  4063. EXPECT_THAT(client.completion_status().error_code,
  4064. net::test::IsError(net::ERR_INVALID_ARGUMENT));
  4065. // No connection should have been made to the test server.
  4066. EXPECT_EQ(0, connection_listener.GetTotalSocketsSeen());
  4067. }
  4068. }
  4069. }
  4070. // Test that the disable_secure_dns trusted param is passed through to the
  4071. // host resolver.
  4072. TEST_F(NetworkContextTest, TrustedParams_DisableSecureDns) {
  4073. net::EmbeddedTestServer test_server;
  4074. test_server.AddDefaultHandlers(
  4075. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4076. ASSERT_TRUE(test_server.Start());
  4077. auto context_builder = CreateTestURLRequestContextBuilder();
  4078. context_builder->set_host_resolver(std::make_unique<net::MockHostResolver>());
  4079. auto url_request_context = context_builder->Build();
  4080. auto& resolver = *static_cast<net::MockHostResolver*>(
  4081. url_request_context->host_resolver());
  4082. resolver.rules()->AddRule("example.test", test_server.GetIPLiteralString());
  4083. network_context_remote_.reset();
  4084. std::unique_ptr<NetworkContext> network_context =
  4085. std::make_unique<NetworkContext>(
  4086. network_service_.get(),
  4087. network_context_remote_.BindNewPipeAndPassReceiver(),
  4088. url_request_context.get(),
  4089. /*cors_exempt_header_list=*/std::vector<std::string>());
  4090. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4091. mojom::URLLoaderFactoryParamsPtr params =
  4092. mojom::URLLoaderFactoryParams::New();
  4093. params->process_id = mojom::kBrowserProcessId;
  4094. params->is_corb_enabled = false;
  4095. params->is_trusted = true;
  4096. network_context->CreateURLLoaderFactory(
  4097. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4098. for (bool disable_secure_dns : {false, true}) {
  4099. ResourceRequest request;
  4100. request.url = GURL("http://example.test/echo");
  4101. request.load_flags = net::LOAD_BYPASS_CACHE;
  4102. request.trusted_params = ResourceRequest::TrustedParams();
  4103. request.trusted_params->disable_secure_dns = disable_secure_dns;
  4104. mojo::PendingRemote<mojom::URLLoader> loader;
  4105. TestURLLoaderClient client;
  4106. loader_factory->CreateLoaderAndStart(
  4107. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4108. 0 /* options */, request, client.CreateRemote(),
  4109. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4110. client.RunUntilComplete();
  4111. if (disable_secure_dns) {
  4112. EXPECT_EQ(net::SecureDnsPolicy::kDisable,
  4113. resolver.last_secure_dns_policy());
  4114. } else {
  4115. EXPECT_EQ(net::SecureDnsPolicy::kAllow,
  4116. resolver.last_secure_dns_policy());
  4117. }
  4118. }
  4119. }
  4120. // Test that the disable_secure_dns factory param is passed through to the
  4121. // host resolver.
  4122. TEST_F(NetworkContextTest, FactoryParams_DisableSecureDns) {
  4123. net::EmbeddedTestServer test_server;
  4124. test_server.AddDefaultHandlers(
  4125. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4126. ASSERT_TRUE(test_server.Start());
  4127. auto context_builder = CreateTestURLRequestContextBuilder();
  4128. context_builder->set_host_resolver(std::make_unique<net::MockHostResolver>());
  4129. auto url_request_context = context_builder->Build();
  4130. auto& resolver = *static_cast<net::MockHostResolver*>(
  4131. url_request_context->host_resolver());
  4132. resolver.rules()->AddRule("example.test", test_server.GetIPLiteralString());
  4133. network_context_remote_.reset();
  4134. NetworkContext network_context(
  4135. network_service_.get(),
  4136. network_context_remote_.BindNewPipeAndPassReceiver(),
  4137. url_request_context.get(),
  4138. /*cors_exempt_header_list=*/std::vector<std::string>());
  4139. for (bool disable_secure_dns : {false, true}) {
  4140. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4141. mojom::URLLoaderFactoryParamsPtr params =
  4142. mojom::URLLoaderFactoryParams::New();
  4143. params->process_id = mojom::kBrowserProcessId;
  4144. params->is_corb_enabled = false;
  4145. params->disable_secure_dns = disable_secure_dns;
  4146. network_context.CreateURLLoaderFactory(
  4147. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4148. ResourceRequest request;
  4149. request.url = GURL("http://example.test/echo");
  4150. request.load_flags = net::LOAD_BYPASS_CACHE;
  4151. auto client = std::make_unique<TestURLLoaderClient>();
  4152. mojo::Remote<mojom::URLLoader> loader;
  4153. loader_factory->CreateLoaderAndStart(
  4154. loader.BindNewPipeAndPassReceiver(), 0 /* request_id */,
  4155. 0 /* options */, request, client->CreateRemote(),
  4156. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4157. client->RunUntilComplete();
  4158. if (disable_secure_dns) {
  4159. EXPECT_EQ(net::SecureDnsPolicy::kDisable,
  4160. resolver.last_secure_dns_policy());
  4161. } else {
  4162. EXPECT_EQ(net::SecureDnsPolicy::kAllow,
  4163. resolver.last_secure_dns_policy());
  4164. }
  4165. }
  4166. }
  4167. #if BUILDFLAG(IS_CT_SUPPORTED)
  4168. TEST_F(NetworkContextTest, ExpectCT) {
  4169. base::test::ScopedFeatureList feature_list;
  4170. feature_list.InitAndEnableFeature(
  4171. net::features::kPartitionExpectCTStateByNetworkIsolationKey);
  4172. std::unique_ptr<NetworkContext> network_context =
  4173. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4174. const char kTestDomain[] = "example.com";
  4175. const base::Time expiry = base::Time::Now() + base::Seconds(1000);
  4176. const bool enforce = true;
  4177. const GURL report_uri = GURL("https://example.com/foo/bar");
  4178. net::NetworkIsolationKey network_isolation_key =
  4179. net::NetworkIsolationKey::CreateTransient();
  4180. // Assert we start with no data for the test host.
  4181. {
  4182. base::Value::Dict state;
  4183. base::RunLoop run_loop;
  4184. network_context->GetExpectCTState(
  4185. kTestDomain, network_isolation_key,
  4186. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4187. run_loop.Run();
  4188. absl::optional<bool> result = state.FindBool("result");
  4189. EXPECT_TRUE(result.has_value());
  4190. EXPECT_EQ(false, *result);
  4191. }
  4192. // Add the host data.
  4193. {
  4194. base::RunLoop run_loop;
  4195. bool result = false;
  4196. network_context->AddExpectCT(
  4197. kTestDomain, expiry, enforce, report_uri, network_isolation_key,
  4198. base::BindOnce(&StoreBool, &result, run_loop.QuitClosure()));
  4199. run_loop.Run();
  4200. EXPECT_TRUE(result);
  4201. }
  4202. // Assert added host data is returned.
  4203. {
  4204. base::Value::Dict state;
  4205. base::RunLoop run_loop;
  4206. network_context->GetExpectCTState(
  4207. kTestDomain, network_isolation_key,
  4208. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4209. run_loop.Run();
  4210. const std::string* dynamic_expect_ct_domain =
  4211. state.FindString("dynamic_expect_ct_domain");
  4212. ASSERT_TRUE(dynamic_expect_ct_domain);
  4213. EXPECT_EQ(kTestDomain, *dynamic_expect_ct_domain);
  4214. absl::optional<double> dynamic_expect_ct_expiry =
  4215. state.FindDouble("dynamic_expect_ct_expiry");
  4216. EXPECT_EQ(expiry.ToDoubleT(), dynamic_expect_ct_expiry);
  4217. absl::optional<bool> dynamic_expect_ct_enforce =
  4218. state.FindBool("dynamic_expect_ct_enforce");
  4219. EXPECT_EQ(enforce, *dynamic_expect_ct_enforce);
  4220. const std::string* dynamic_expect_ct_report_uri =
  4221. state.FindString("dynamic_expect_ct_report_uri");
  4222. ASSERT_TRUE(dynamic_expect_ct_report_uri);
  4223. EXPECT_EQ(report_uri, *dynamic_expect_ct_report_uri);
  4224. }
  4225. // Using a different NetworkIsolationKey should return no result.
  4226. {
  4227. base::Value::Dict state;
  4228. base::RunLoop run_loop;
  4229. network_context->GetExpectCTState(
  4230. kTestDomain, net::NetworkIsolationKey::CreateTransient(),
  4231. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4232. run_loop.Run();
  4233. absl::optional<bool> result = state.FindBool("result");
  4234. EXPECT_TRUE(result.has_value());
  4235. EXPECT_EQ(false, *result);
  4236. }
  4237. // Delete host data.
  4238. {
  4239. bool result;
  4240. base::RunLoop run_loop;
  4241. network_context->DeleteDynamicDataForHost(
  4242. kTestDomain,
  4243. base::BindOnce(&StoreBool, &result, run_loop.QuitClosure()));
  4244. run_loop.Run();
  4245. EXPECT_TRUE(result);
  4246. }
  4247. // Assert data is removed.
  4248. {
  4249. base::Value::Dict state;
  4250. base::RunLoop run_loop;
  4251. network_context->GetExpectCTState(
  4252. kTestDomain, network_isolation_key,
  4253. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4254. run_loop.Run();
  4255. absl::optional<bool> result = state.FindBool("result");
  4256. EXPECT_TRUE(result.has_value());
  4257. EXPECT_EQ(false, *result);
  4258. }
  4259. }
  4260. TEST_F(NetworkContextTest, SetExpectCTTestReport) {
  4261. std::unique_ptr<NetworkContext> network_context =
  4262. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4263. net::EmbeddedTestServer test_server;
  4264. std::set<GURL> requested_urls;
  4265. auto monitor_callback = base::BindLambdaForTesting(
  4266. [&](const net::test_server::HttpRequest& request) {
  4267. requested_urls.insert(request.GetURL());
  4268. });
  4269. test_server.RegisterRequestMonitor(monitor_callback);
  4270. ASSERT_TRUE(test_server.Start());
  4271. const GURL kReportURL = test_server.base_url().Resolve("/report/path");
  4272. base::RunLoop run_loop;
  4273. bool result = false;
  4274. network_context->SetExpectCTTestReport(
  4275. kReportURL, base::BindOnce(&StoreBool, &result, run_loop.QuitClosure()));
  4276. run_loop.Run();
  4277. EXPECT_FALSE(result);
  4278. EXPECT_TRUE(base::Contains(requested_urls, kReportURL));
  4279. }
  4280. #endif // BUILDFLAG(IS_CT_SUPPORTED)
  4281. TEST_F(NetworkContextTest, QueryHSTS) {
  4282. const char kTestDomain[] = "example.com";
  4283. std::unique_ptr<NetworkContext> network_context =
  4284. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4285. bool result = false, got_result = false;
  4286. network_context->IsHSTSActiveForHost(
  4287. kTestDomain, base::BindLambdaForTesting([&](bool is_hsts) {
  4288. result = is_hsts;
  4289. got_result = true;
  4290. }));
  4291. EXPECT_TRUE(got_result);
  4292. EXPECT_FALSE(result);
  4293. base::RunLoop run_loop;
  4294. network_context->AddHSTS(kTestDomain, base::Time::Now() + base::Days(1000),
  4295. false /*include_subdomains*/,
  4296. run_loop.QuitClosure());
  4297. run_loop.Run();
  4298. bool result2 = false, got_result2 = false;
  4299. network_context->IsHSTSActiveForHost(
  4300. kTestDomain, base::BindLambdaForTesting([&](bool is_hsts) {
  4301. result2 = is_hsts;
  4302. got_result2 = true;
  4303. }));
  4304. EXPECT_TRUE(got_result2);
  4305. EXPECT_TRUE(result2);
  4306. }
  4307. TEST_F(NetworkContextTest, GetHSTSState) {
  4308. const char kTestDomain[] = "example.com";
  4309. const base::Time expiry = base::Time::Now() + base::Seconds(1000);
  4310. const GURL report_uri = GURL("https://example.com/foo/bar");
  4311. std::unique_ptr<NetworkContext> network_context =
  4312. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4313. base::Value::Dict state;
  4314. {
  4315. base::RunLoop run_loop;
  4316. network_context->GetHSTSState(
  4317. kTestDomain,
  4318. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4319. run_loop.Run();
  4320. }
  4321. absl::optional<bool> result = state.FindBool("result");
  4322. ASSERT_TRUE(result.has_value());
  4323. EXPECT_FALSE(*result);
  4324. {
  4325. base::RunLoop run_loop;
  4326. network_context->AddHSTS(kTestDomain, expiry, false /*include_subdomains*/,
  4327. run_loop.QuitClosure());
  4328. run_loop.Run();
  4329. }
  4330. {
  4331. base::RunLoop run_loop;
  4332. network_context->GetHSTSState(
  4333. kTestDomain,
  4334. base::BindOnce(&StoreValue, &state, run_loop.QuitClosure()));
  4335. run_loop.Run();
  4336. }
  4337. result = state.FindBool("result");
  4338. ASSERT_TRUE(result.has_value());
  4339. EXPECT_TRUE(*result);
  4340. // Not checking all values - only enough to ensure the underlying call
  4341. // was made.
  4342. const std::string* dynamic_sts_domain =
  4343. state.FindString("dynamic_sts_domain");
  4344. ASSERT_TRUE(dynamic_sts_domain);
  4345. EXPECT_EQ(kTestDomain, *dynamic_sts_domain);
  4346. absl::optional<double> dynamic_sts_expiry =
  4347. state.FindDouble("dynamic_sts_expiry");
  4348. EXPECT_EQ(expiry.ToDoubleT(), dynamic_sts_expiry);
  4349. }
  4350. TEST_F(NetworkContextTest, ForceReloadProxyConfig) {
  4351. std::unique_ptr<NetworkContext> network_context =
  4352. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4353. auto net_log_exporter =
  4354. std::make_unique<network::NetLogExporter>(network_context.get());
  4355. base::FilePath net_log_path;
  4356. ASSERT_TRUE(base::CreateTemporaryFile(&net_log_path));
  4357. {
  4358. base::File net_log_file(
  4359. net_log_path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  4360. EXPECT_TRUE(net_log_file.IsValid());
  4361. base::RunLoop run_loop;
  4362. int32_t start_param = 0;
  4363. auto start_callback = base::BindLambdaForTesting([&](int32_t result) {
  4364. start_param = result;
  4365. run_loop.Quit();
  4366. });
  4367. net_log_exporter->Start(std::move(net_log_file),
  4368. /*extra_constants=*/base::Value::Dict(),
  4369. net::NetLogCaptureMode::kDefault,
  4370. network::mojom::NetLogExporter::kUnlimitedFileSize,
  4371. start_callback);
  4372. run_loop.Run();
  4373. EXPECT_EQ(net::OK, start_param);
  4374. }
  4375. {
  4376. base::RunLoop run_loop;
  4377. network_context->ForceReloadProxyConfig(run_loop.QuitClosure());
  4378. run_loop.Run();
  4379. }
  4380. {
  4381. base::RunLoop run_loop;
  4382. int32_t stop_param = 0;
  4383. auto stop_callback = base::BindLambdaForTesting([&](int32_t result) {
  4384. stop_param = result;
  4385. run_loop.Quit();
  4386. });
  4387. net_log_exporter->Stop(
  4388. /*polled_data=*/base::Value::Dict(), stop_callback);
  4389. run_loop.Run();
  4390. EXPECT_EQ(net::OK, stop_param);
  4391. }
  4392. std::string log_contents;
  4393. EXPECT_TRUE(base::ReadFileToString(net_log_path, &log_contents));
  4394. EXPECT_NE(std::string::npos, log_contents.find("\"new_config\""))
  4395. << log_contents;
  4396. base::DeleteFile(net_log_path);
  4397. }
  4398. TEST_F(NetworkContextTest, ClearBadProxiesCache) {
  4399. std::unique_ptr<NetworkContext> network_context =
  4400. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4401. net::ProxyResolutionService* proxy_resolution_service =
  4402. network_context->url_request_context()->proxy_resolution_service();
  4403. // Very starting conditions: zero bad proxies.
  4404. EXPECT_EQ(0UL, proxy_resolution_service->proxy_retry_info().size());
  4405. // Simulate network error to add one proxy to the bad proxy list.
  4406. net::ProxyInfo proxy_info;
  4407. proxy_info.UseNamedProxy("http://foo1.com");
  4408. proxy_resolution_service->ReportSuccess(proxy_info);
  4409. std::vector<net::ProxyServer> proxies;
  4410. proxies.push_back(net::ProxyUriToProxyServer("http://foo1.com",
  4411. net::ProxyServer::SCHEME_HTTP));
  4412. proxy_resolution_service->MarkProxiesAsBadUntil(
  4413. proxy_info, base::Days(1), proxies, net::NetLogWithSource());
  4414. base::RunLoop().RunUntilIdle();
  4415. EXPECT_EQ(1UL, proxy_resolution_service->proxy_retry_info().size());
  4416. // Clear the bad proxies.
  4417. base::RunLoop run_loop;
  4418. network_context->ClearBadProxiesCache(run_loop.QuitClosure());
  4419. run_loop.Run();
  4420. // Verify all cleared.
  4421. EXPECT_EQ(0UL, proxy_resolution_service->proxy_retry_info().size());
  4422. }
  4423. // This is a test ProxyErrorClient that records the sequence of calls made to
  4424. // OnPACScriptError() and OnRequestMaybeFailedDueToProxySettings().
  4425. class TestProxyErrorClient final : public mojom::ProxyErrorClient {
  4426. public:
  4427. struct PacScriptError {
  4428. int line = -1;
  4429. std::string details;
  4430. };
  4431. TestProxyErrorClient() = default;
  4432. TestProxyErrorClient(const TestProxyErrorClient&) = delete;
  4433. TestProxyErrorClient& operator=(const TestProxyErrorClient&) = delete;
  4434. ~TestProxyErrorClient() override {}
  4435. void OnPACScriptError(int32_t line_number,
  4436. const std::string& details) override {
  4437. on_pac_script_error_calls_.push_back({line_number, details});
  4438. }
  4439. void OnRequestMaybeFailedDueToProxySettings(int32_t net_error) override {
  4440. on_request_maybe_failed_calls_.push_back(net_error);
  4441. }
  4442. const std::vector<int>& on_request_maybe_failed_calls() const {
  4443. return on_request_maybe_failed_calls_;
  4444. }
  4445. const std::vector<PacScriptError>& on_pac_script_error_calls() const {
  4446. return on_pac_script_error_calls_;
  4447. }
  4448. // Creates an mojo::PendingRemote, binds it to |*this| and returns it.
  4449. mojo::PendingRemote<mojom::ProxyErrorClient> CreateRemote() {
  4450. mojo::PendingRemote<mojom::ProxyErrorClient> client_remote =
  4451. receiver_.BindNewPipeAndPassRemote();
  4452. receiver_.set_disconnect_handler(base::BindOnce(
  4453. &TestProxyErrorClient::OnMojoPipeError, base::Unretained(this)));
  4454. return client_remote;
  4455. }
  4456. // Runs until the message pipe is closed due to an error.
  4457. void RunUntilMojoPipeError() {
  4458. if (has_received_mojo_pipe_error_)
  4459. return;
  4460. base::RunLoop run_loop;
  4461. quit_closure_for_on_mojo_pipe_error_ = run_loop.QuitClosure();
  4462. run_loop.Run();
  4463. }
  4464. private:
  4465. void OnMojoPipeError() {
  4466. if (has_received_mojo_pipe_error_)
  4467. return;
  4468. has_received_mojo_pipe_error_ = true;
  4469. if (quit_closure_for_on_mojo_pipe_error_)
  4470. std::move(quit_closure_for_on_mojo_pipe_error_).Run();
  4471. }
  4472. mojo::Receiver<mojom::ProxyErrorClient> receiver_{this};
  4473. base::OnceClosure quit_closure_for_on_mojo_pipe_error_;
  4474. bool has_received_mojo_pipe_error_ = false;
  4475. std::vector<int> on_request_maybe_failed_calls_;
  4476. std::vector<PacScriptError> on_pac_script_error_calls_;
  4477. };
  4478. // While in scope, all host resolutions will fail with ERR_NAME_NOT_RESOLVED,
  4479. // including localhost (so this precludes the use of embedded test server).
  4480. class ScopedFailAllHostResolutions {
  4481. public:
  4482. ScopedFailAllHostResolutions()
  4483. : mock_resolver_proc_(new net::RuleBasedHostResolverProc(nullptr)),
  4484. default_resolver_proc_(mock_resolver_proc_.get()) {
  4485. mock_resolver_proc_->AddSimulatedFailure("*");
  4486. }
  4487. private:
  4488. scoped_refptr<net::RuleBasedHostResolverProc> mock_resolver_proc_;
  4489. net::ScopedDefaultHostResolverProc default_resolver_proc_;
  4490. };
  4491. // Tests that when a ProxyErrorClient is provided to NetworkContextParams, this
  4492. // client's OnRequestMaybeFailedDueToProxySettings() method is called exactly
  4493. // once when a request fails due to a proxy server connectivity failure.
  4494. TEST_F(NetworkContextTest, ProxyErrorClientNotifiedOfProxyConnection) {
  4495. // Avoid the test having a network dependency on DNS.
  4496. ScopedFailAllHostResolutions fail_dns;
  4497. // Set up the NetworkContext, such that it uses an unreachable proxy
  4498. // (proxy and is configured to send "proxy errors" to
  4499. // |proxy_error_client|.
  4500. TestProxyErrorClient proxy_error_client;
  4501. mojom::NetworkContextParamsPtr context_params =
  4502. CreateNetworkContextParamsForTesting();
  4503. context_params->proxy_error_client = proxy_error_client.CreateRemote();
  4504. net::ProxyConfig proxy_config;
  4505. // Set the proxy to an unreachable address (host resolution fails).
  4506. proxy_config.proxy_rules().ParseFromString("proxy.bad.dns");
  4507. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  4508. proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS);
  4509. std::unique_ptr<NetworkContext> network_context =
  4510. CreateContextWithParams(std::move(context_params));
  4511. // Issue an HTTP request. It doesn't matter exactly what the URL is, since it
  4512. // will be sent to the proxy.
  4513. ResourceRequest request;
  4514. request.url = GURL("http://example.test");
  4515. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4516. mojom::URLLoaderFactoryParamsPtr loader_params =
  4517. mojom::URLLoaderFactoryParams::New();
  4518. loader_params->process_id = mojom::kBrowserProcessId;
  4519. network_context->CreateURLLoaderFactory(
  4520. loader_factory.BindNewPipeAndPassReceiver(), std::move(loader_params));
  4521. mojo::PendingRemote<mojom::URLLoader> loader;
  4522. TestURLLoaderClient client;
  4523. loader_factory->CreateLoaderAndStart(
  4524. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4525. 0 /* options */, request, client.CreateRemote(),
  4526. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4527. // Confirm the the resource request failed due to an unreachable proxy.
  4528. client.RunUntilComplete();
  4529. EXPECT_THAT(client.completion_status().error_code,
  4530. net::test::IsError(net::ERR_PROXY_CONNECTION_FAILED));
  4531. // Tear down the network context and wait for a pipe error to ensure
  4532. // that all queued messages on |proxy_error_client| have been processed.
  4533. network_context.reset();
  4534. proxy_error_client.RunUntilMojoPipeError();
  4535. // Confirm that the ProxyErrorClient received the expected calls.
  4536. const auto& request_errors =
  4537. proxy_error_client.on_request_maybe_failed_calls();
  4538. const auto& pac_errors = proxy_error_client.on_pac_script_error_calls();
  4539. ASSERT_EQ(1u, request_errors.size());
  4540. EXPECT_THAT(request_errors[0],
  4541. net::test::IsError(net::ERR_PROXY_CONNECTION_FAILED));
  4542. EXPECT_EQ(0u, pac_errors.size());
  4543. }
  4544. // Tests that when a ProxyErrorClient is provided to NetworkContextParams, this
  4545. // client's OnRequestMaybeFailedDueToProxySettings() method is
  4546. // NOT called when a request fails due to a non-proxy related error (in this
  4547. // case the target host is unreachable).
  4548. TEST_F(NetworkContextTest, ProxyErrorClientNotNotifiedOfUnreachableError) {
  4549. // Avoid the test having a network dependency on DNS.
  4550. ScopedFailAllHostResolutions fail_dns;
  4551. // Set up the NetworkContext that uses the default DIRECT proxy
  4552. // configuration.
  4553. TestProxyErrorClient proxy_error_client;
  4554. mojom::NetworkContextParamsPtr context_params =
  4555. CreateNetworkContextParamsForTesting();
  4556. context_params->proxy_error_client = proxy_error_client.CreateRemote();
  4557. std::unique_ptr<NetworkContext> network_context =
  4558. CreateContextWithParams(std::move(context_params));
  4559. // Issue an HTTP request to an unreachable URL.
  4560. ResourceRequest request;
  4561. request.url = GURL("http://server.bad.dns/fail");
  4562. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4563. mojom::URLLoaderFactoryParamsPtr loader_params =
  4564. mojom::URLLoaderFactoryParams::New();
  4565. loader_params->process_id = mojom::kBrowserProcessId;
  4566. network_context->CreateURLLoaderFactory(
  4567. loader_factory.BindNewPipeAndPassReceiver(), std::move(loader_params));
  4568. mojo::PendingRemote<mojom::URLLoader> loader;
  4569. TestURLLoaderClient client;
  4570. loader_factory->CreateLoaderAndStart(
  4571. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4572. 0 /* options */, request, client.CreateRemote(),
  4573. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4574. // Confirm the the resource request failed.
  4575. client.RunUntilComplete();
  4576. EXPECT_THAT(client.completion_status().error_code,
  4577. net::test::IsError(net::ERR_NAME_NOT_RESOLVED));
  4578. // Tear down the network context and wait for a pipe error to ensure
  4579. // that all queued messages on |proxy_error_client| have been processed.
  4580. network_context.reset();
  4581. proxy_error_client.RunUntilMojoPipeError();
  4582. // Confirm that the ProxyErrorClient received no calls.
  4583. const auto& request_errors =
  4584. proxy_error_client.on_request_maybe_failed_calls();
  4585. const auto& pac_errors = proxy_error_client.on_pac_script_error_calls();
  4586. EXPECT_EQ(0u, request_errors.size());
  4587. EXPECT_EQ(0u, pac_errors.size());
  4588. }
  4589. // Tests that when a ProxyErrorClient is provided to NetworkContextParams, this
  4590. // client's OnPACScriptError() method is called whenever the PAC script throws
  4591. // an error.
  4592. TEST_F(NetworkContextTest, ProxyErrorClientNotifiedOfPacError) {
  4593. // Avoid the test having a network dependency on DNS.
  4594. ScopedFailAllHostResolutions fail_dns;
  4595. // Set up the NetworkContext so that it sends "proxy errors" to
  4596. // |proxy_error_client|, and uses a mock ProxyResolverFactory that emits
  4597. // script errors.
  4598. TestProxyErrorClient proxy_error_client;
  4599. mojom::NetworkContextParamsPtr context_params =
  4600. CreateNetworkContextParamsForTesting();
  4601. context_params->proxy_error_client = proxy_error_client.CreateRemote();
  4602. #if BUILDFLAG(IS_CHROMEOS_ASH)
  4603. context_params->dhcp_wpad_url_client =
  4604. network::MockMojoDhcpWpadUrlClient::CreateWithSelfOwnedReceiver(
  4605. std::string());
  4606. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  4607. // The PAC URL doesn't matter, since the test is configured to use a
  4608. // mock ProxyResolverFactory which doesn't actually evaluate it. It just
  4609. // needs to be a data: URL to ensure the network fetch doesn't fail.
  4610. //
  4611. // That said, the mock PAC evaluator being used behaves similarly to the
  4612. // script embedded in the data URL below.
  4613. net::ProxyConfig proxy_config = net::ProxyConfig::CreateFromCustomPacURL(
  4614. GURL("data:,function FindProxyForURL(url,host){throw url}"));
  4615. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  4616. proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS);
  4617. context_params->proxy_resolver_factory =
  4618. MockMojoProxyResolverFactory::Create();
  4619. std::unique_ptr<NetworkContext> network_context =
  4620. CreateContextWithParams(std::move(context_params));
  4621. // Issue an HTTP request. This will end up being sent DIRECT since the PAC
  4622. // script is broken.
  4623. ResourceRequest request;
  4624. request.url = GURL("http://server.bad.dns");
  4625. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4626. mojom::URLLoaderFactoryParamsPtr loader_params =
  4627. mojom::URLLoaderFactoryParams::New();
  4628. loader_params->process_id = mojom::kBrowserProcessId;
  4629. network_context->CreateURLLoaderFactory(
  4630. loader_factory.BindNewPipeAndPassReceiver(), std::move(loader_params));
  4631. mojo::PendingRemote<mojom::URLLoader> loader;
  4632. TestURLLoaderClient client;
  4633. loader_factory->CreateLoaderAndStart(
  4634. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4635. 0 /* options */, request, client.CreateRemote(),
  4636. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4637. // Confirm the the resource request failed.
  4638. client.RunUntilComplete();
  4639. EXPECT_THAT(client.completion_status().error_code,
  4640. net::test::IsError(net::ERR_NAME_NOT_RESOLVED));
  4641. // Tear down the network context and wait for a pipe error to ensure
  4642. // that all queued messages on |proxy_error_client| have been processed.
  4643. network_context.reset();
  4644. proxy_error_client.RunUntilMojoPipeError();
  4645. // Confirm that the ProxyErrorClient received the expected calls.
  4646. const auto& request_errors =
  4647. proxy_error_client.on_request_maybe_failed_calls();
  4648. const auto& pac_errors = proxy_error_client.on_pac_script_error_calls();
  4649. EXPECT_EQ(0u, request_errors.size());
  4650. ASSERT_EQ(1u, pac_errors.size());
  4651. EXPECT_EQ(pac_errors[0].line, 42);
  4652. EXPECT_EQ(pac_errors[0].details,
  4653. "Failed: FindProxyForURL(url=http://server.bad.dns/)");
  4654. }
  4655. // Test ensures that ProxyServer data is populated correctly across Mojo calls.
  4656. // Basically it performs a set of URLLoader network requests, whose requests
  4657. // configure proxies. Then it checks whether the expected proxy scheme is
  4658. // respected.
  4659. TEST_F(NetworkContextTest, EnsureProperProxyServerIsUsed) {
  4660. net::test_server::EmbeddedTestServer test_server;
  4661. test_server.AddDefaultHandlers(
  4662. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4663. ASSERT_TRUE(test_server.Start());
  4664. struct ProxyConfigSet {
  4665. net::ProxyConfig proxy_config;
  4666. GURL url;
  4667. net::ProxyServer::Scheme expected_proxy_config_scheme;
  4668. } proxy_config_set[2];
  4669. proxy_config_set[0].proxy_config.proxy_rules().ParseFromString(
  4670. "http=" + test_server.host_port_pair().ToString());
  4671. proxy_config_set[0].url = GURL("http://does.not.matter/echo");
  4672. proxy_config_set[0].expected_proxy_config_scheme =
  4673. net::ProxyServer::SCHEME_HTTP;
  4674. proxy_config_set[1].proxy_config.proxy_rules().ParseFromString(
  4675. "http=direct://");
  4676. proxy_config_set[1]
  4677. .proxy_config.proxy_rules()
  4678. .bypass_rules.AddRulesToSubtractImplicit();
  4679. proxy_config_set[1].url = test_server.GetURL("/echo");
  4680. proxy_config_set[1].expected_proxy_config_scheme =
  4681. net::ProxyServer::SCHEME_DIRECT;
  4682. for (const auto& proxy_data : proxy_config_set) {
  4683. mojom::NetworkContextParamsPtr context_params =
  4684. CreateNetworkContextParamsForTesting();
  4685. context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
  4686. proxy_data.proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS);
  4687. mojo::Remote<mojom::ProxyConfigClient> config_client;
  4688. context_params->proxy_config_client_receiver =
  4689. config_client.BindNewPipeAndPassReceiver();
  4690. std::unique_ptr<NetworkContext> network_context =
  4691. CreateContextWithParams(std::move(context_params));
  4692. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4693. mojom::URLLoaderFactoryParamsPtr params =
  4694. mojom::URLLoaderFactoryParams::New();
  4695. params->process_id = 0;
  4696. network_context->CreateURLLoaderFactory(
  4697. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4698. ResourceRequest request;
  4699. request.url = proxy_data.url;
  4700. mojo::PendingRemote<mojom::URLLoader> loader;
  4701. TestURLLoaderClient client;
  4702. loader_factory->CreateLoaderAndStart(
  4703. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4704. 0 /* options */, request, client.CreateRemote(),
  4705. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4706. client.RunUntilComplete();
  4707. EXPECT_TRUE(client.has_received_completion());
  4708. EXPECT_EQ(client.response_head()->proxy_server.scheme(),
  4709. proxy_data.expected_proxy_config_scheme);
  4710. }
  4711. }
  4712. class TestURLLoaderHeaderClient : public mojom::TrustedURLLoaderHeaderClient {
  4713. public:
  4714. class TestHeaderClient : public mojom::TrustedHeaderClient {
  4715. public:
  4716. TestHeaderClient() {}
  4717. TestHeaderClient(const TestHeaderClient&) = delete;
  4718. TestHeaderClient& operator=(const TestHeaderClient&) = delete;
  4719. // network::mojom::TrustedHeaderClient:
  4720. void OnBeforeSendHeaders(const net::HttpRequestHeaders& headers,
  4721. OnBeforeSendHeadersCallback callback) override {
  4722. auto new_headers = headers;
  4723. new_headers.SetHeader("foo", "bar");
  4724. std::move(callback).Run(on_before_send_headers_result_, new_headers);
  4725. }
  4726. void OnHeadersReceived(const std::string& headers,
  4727. const net::IPEndPoint& endpoint,
  4728. OnHeadersReceivedCallback callback) override {
  4729. auto new_headers =
  4730. base::MakeRefCounted<net::HttpResponseHeaders>(headers);
  4731. new_headers->SetHeader("baz", "qux");
  4732. std::move(callback).Run(on_headers_received_result_,
  4733. new_headers->raw_headers(), GURL());
  4734. }
  4735. void set_on_before_send_headers_result(int result) {
  4736. on_before_send_headers_result_ = result;
  4737. }
  4738. void set_on_headers_received_result(int result) {
  4739. on_headers_received_result_ = result;
  4740. }
  4741. void Bind(
  4742. mojo::PendingReceiver<network::mojom::TrustedHeaderClient> receiver) {
  4743. receiver_.reset();
  4744. receiver_.Bind(std::move(receiver));
  4745. }
  4746. private:
  4747. int on_before_send_headers_result_ = net::OK;
  4748. int on_headers_received_result_ = net::OK;
  4749. mojo::Receiver<mojom::TrustedHeaderClient> receiver_{this};
  4750. };
  4751. explicit TestURLLoaderHeaderClient(
  4752. mojo::PendingReceiver<mojom::TrustedURLLoaderHeaderClient> receiver)
  4753. : receiver_(this, std::move(receiver)) {}
  4754. TestURLLoaderHeaderClient(const TestURLLoaderHeaderClient&) = delete;
  4755. TestURLLoaderHeaderClient& operator=(const TestURLLoaderHeaderClient&) =
  4756. delete;
  4757. // network::mojom::TrustedURLLoaderHeaderClient:
  4758. void OnLoaderCreated(
  4759. int32_t request_id,
  4760. mojo::PendingReceiver<network::mojom::TrustedHeaderClient> receiver)
  4761. override {
  4762. header_client_.Bind(std::move(receiver));
  4763. }
  4764. void OnLoaderForCorsPreflightCreated(
  4765. const ResourceRequest& request,
  4766. mojo::PendingReceiver<mojom::TrustedHeaderClient> receiver) override {
  4767. header_client_.Bind(std::move(receiver));
  4768. }
  4769. void set_on_before_send_headers_result(int result) {
  4770. header_client_.set_on_before_send_headers_result(result);
  4771. }
  4772. void set_on_headers_received_result(int result) {
  4773. header_client_.set_on_headers_received_result(result);
  4774. }
  4775. private:
  4776. TestHeaderClient header_client_;
  4777. mojo::Receiver<mojom::TrustedURLLoaderHeaderClient> receiver_;
  4778. };
  4779. TEST_F(NetworkContextTest, HeaderClientModifiesHeaders) {
  4780. net::EmbeddedTestServer test_server;
  4781. net::test_server::RegisterDefaultHandlers(&test_server);
  4782. ASSERT_TRUE(test_server.Start());
  4783. std::unique_ptr<NetworkContext> network_context =
  4784. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4785. ResourceRequest request;
  4786. request.url = test_server.GetURL("/echoheader?foo");
  4787. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4788. mojom::URLLoaderFactoryParamsPtr params =
  4789. mojom::URLLoaderFactoryParams::New();
  4790. params->process_id = mojom::kBrowserProcessId;
  4791. params->is_corb_enabled = false;
  4792. TestURLLoaderHeaderClient header_client(
  4793. params->header_client.InitWithNewPipeAndPassReceiver());
  4794. network_context->CreateURLLoaderFactory(
  4795. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4796. // First, do a request with kURLLoadOptionUseHeaderClient set.
  4797. {
  4798. mojo::PendingRemote<mojom::URLLoader> loader;
  4799. TestURLLoaderClient client;
  4800. loader_factory->CreateLoaderAndStart(
  4801. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4802. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  4803. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4804. client.RunUntilComplete();
  4805. // Make sure request header was modified. The value will be in the body
  4806. // since we used the /echoheader endpoint.
  4807. std::string response;
  4808. EXPECT_TRUE(
  4809. mojo::BlockingCopyToString(client.response_body_release(), &response));
  4810. EXPECT_EQ(response, "bar");
  4811. // Make sure response header was modified.
  4812. EXPECT_TRUE(client.response_head()->headers->HasHeaderValue("baz", "qux"));
  4813. }
  4814. // Next, do a request without kURLLoadOptionUseHeaderClient set, headers
  4815. // should not be modified.
  4816. {
  4817. mojo::PendingRemote<mojom::URLLoader> loader;
  4818. TestURLLoaderClient client;
  4819. loader_factory->CreateLoaderAndStart(
  4820. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4821. 0 /* options */, request, client.CreateRemote(),
  4822. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4823. client.RunUntilComplete();
  4824. // Make sure request header was not set.
  4825. std::string response;
  4826. EXPECT_TRUE(
  4827. mojo::BlockingCopyToString(client.response_body_release(), &response));
  4828. EXPECT_EQ(response, "None");
  4829. // Make sure response header was not set.
  4830. EXPECT_FALSE(client.response_head()->headers->HasHeaderValue("foo", "bar"));
  4831. }
  4832. }
  4833. TEST_F(NetworkContextTest, HeaderClientFailsRequest) {
  4834. net::EmbeddedTestServer test_server;
  4835. net::test_server::RegisterDefaultHandlers(&test_server);
  4836. ASSERT_TRUE(test_server.Start());
  4837. std::unique_ptr<NetworkContext> network_context =
  4838. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4839. ResourceRequest request;
  4840. request.url = test_server.GetURL("/echo");
  4841. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4842. mojom::URLLoaderFactoryParamsPtr params =
  4843. mojom::URLLoaderFactoryParams::New();
  4844. params->process_id = mojom::kBrowserProcessId;
  4845. params->is_corb_enabled = false;
  4846. TestURLLoaderHeaderClient header_client(
  4847. params->header_client.InitWithNewPipeAndPassReceiver());
  4848. network_context->CreateURLLoaderFactory(
  4849. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4850. // First, fail request on OnBeforeSendHeaders.
  4851. {
  4852. header_client.set_on_before_send_headers_result(net::ERR_FAILED);
  4853. mojo::PendingRemote<mojom::URLLoader> loader;
  4854. TestURLLoaderClient client;
  4855. loader_factory->CreateLoaderAndStart(
  4856. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4857. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  4858. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4859. client.RunUntilComplete();
  4860. EXPECT_EQ(client.completion_status().error_code, net::ERR_FAILED);
  4861. }
  4862. // Next, fail request on OnHeadersReceived.
  4863. {
  4864. header_client.set_on_before_send_headers_result(net::OK);
  4865. header_client.set_on_headers_received_result(net::ERR_FAILED);
  4866. mojo::PendingRemote<mojom::URLLoader> loader;
  4867. TestURLLoaderClient client;
  4868. loader_factory->CreateLoaderAndStart(
  4869. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4870. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  4871. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4872. client.RunUntilComplete();
  4873. EXPECT_EQ(client.completion_status().error_code, net::ERR_FAILED);
  4874. }
  4875. }
  4876. class HangingTestURLLoaderHeaderClient
  4877. : public mojom::TrustedURLLoaderHeaderClient {
  4878. public:
  4879. class TestHeaderClient : public mojom::TrustedHeaderClient {
  4880. public:
  4881. TestHeaderClient() {}
  4882. TestHeaderClient(const TestHeaderClient&) = delete;
  4883. TestHeaderClient& operator=(const TestHeaderClient&) = delete;
  4884. // network::mojom::TrustedHeaderClient:
  4885. void OnBeforeSendHeaders(const net::HttpRequestHeaders& headers,
  4886. OnBeforeSendHeadersCallback callback) override {
  4887. saved_request_headers_ = headers;
  4888. saved_on_before_send_headers_callback_ = std::move(callback);
  4889. on_before_send_headers_loop_.Quit();
  4890. }
  4891. void OnHeadersReceived(const std::string& headers,
  4892. const net::IPEndPoint& endpoint,
  4893. OnHeadersReceivedCallback callback) override {
  4894. saved_received_headers_ = headers;
  4895. saved_on_headers_received_callback_ = std::move(callback);
  4896. on_headers_received_loop_.Quit();
  4897. }
  4898. void CallOnBeforeSendHeadersCallback() {
  4899. net::HttpRequestHeaders new_headers = std::move(saved_request_headers_);
  4900. new_headers.SetHeader("foo", "bar");
  4901. std::move(saved_on_before_send_headers_callback_)
  4902. .Run(net::OK, new_headers);
  4903. }
  4904. void WaitForOnBeforeSendHeaders() { on_before_send_headers_loop_.Run(); }
  4905. void CallOnHeadersReceivedCallback() {
  4906. auto new_headers = base::MakeRefCounted<net::HttpResponseHeaders>(
  4907. saved_received_headers_);
  4908. new_headers->SetHeader("baz", "qux");
  4909. std::move(saved_on_headers_received_callback_)
  4910. .Run(net::OK, new_headers->raw_headers(), GURL());
  4911. }
  4912. void WaitForOnHeadersReceived() { on_headers_received_loop_.Run(); }
  4913. void Bind(
  4914. mojo::PendingReceiver<network::mojom::TrustedHeaderClient> receiver) {
  4915. receiver_.Bind(std::move(receiver));
  4916. }
  4917. private:
  4918. base::RunLoop on_before_send_headers_loop_;
  4919. net::HttpRequestHeaders saved_request_headers_;
  4920. OnBeforeSendHeadersCallback saved_on_before_send_headers_callback_;
  4921. base::RunLoop on_headers_received_loop_;
  4922. std::string saved_received_headers_;
  4923. OnHeadersReceivedCallback saved_on_headers_received_callback_;
  4924. mojo::Receiver<mojom::TrustedHeaderClient> receiver_{this};
  4925. };
  4926. explicit HangingTestURLLoaderHeaderClient(
  4927. mojo::PendingReceiver<mojom::TrustedURLLoaderHeaderClient> receiver)
  4928. : receiver_(this, std::move(receiver)) {}
  4929. HangingTestURLLoaderHeaderClient(const HangingTestURLLoaderHeaderClient&) =
  4930. delete;
  4931. HangingTestURLLoaderHeaderClient& operator=(
  4932. const HangingTestURLLoaderHeaderClient&) = delete;
  4933. // network::mojom::TrustedURLLoaderHeaderClient:
  4934. void OnLoaderCreated(
  4935. int32_t request_id,
  4936. mojo::PendingReceiver<network::mojom::TrustedHeaderClient> receiver)
  4937. override {
  4938. header_client_.Bind(std::move(receiver));
  4939. }
  4940. void OnLoaderForCorsPreflightCreated(
  4941. const ResourceRequest& request,
  4942. mojo::PendingReceiver<mojom::TrustedHeaderClient> receiver) override {
  4943. header_client_.Bind(std::move(receiver));
  4944. }
  4945. void CallOnBeforeSendHeadersCallback() {
  4946. header_client_.CallOnBeforeSendHeadersCallback();
  4947. }
  4948. void WaitForOnBeforeSendHeaders() {
  4949. header_client_.WaitForOnBeforeSendHeaders();
  4950. }
  4951. void CallOnHeadersReceivedCallback() {
  4952. header_client_.CallOnHeadersReceivedCallback();
  4953. }
  4954. void WaitForOnHeadersReceived() { header_client_.WaitForOnHeadersReceived(); }
  4955. private:
  4956. TestHeaderClient header_client_;
  4957. mojo::Receiver<mojom::TrustedURLLoaderHeaderClient> receiver_;
  4958. };
  4959. // Test waiting on the OnHeadersReceived event, then proceeding to call the
  4960. // OnHeadersReceivedCallback asynchronously. This mostly just verifies that
  4961. // HangingTestURLLoaderHeaderClient works.
  4962. TEST_F(NetworkContextTest, HangingHeaderClientModifiesHeadersAsynchronously) {
  4963. net::EmbeddedTestServer test_server;
  4964. net::test_server::RegisterDefaultHandlers(&test_server);
  4965. ASSERT_TRUE(test_server.Start());
  4966. std::unique_ptr<NetworkContext> network_context =
  4967. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  4968. ResourceRequest request;
  4969. request.url = test_server.GetURL("/echoheader?foo");
  4970. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  4971. mojom::URLLoaderFactoryParamsPtr params =
  4972. mojom::URLLoaderFactoryParams::New();
  4973. params->process_id = mojom::kBrowserProcessId;
  4974. params->is_corb_enabled = false;
  4975. HangingTestURLLoaderHeaderClient header_client(
  4976. params->header_client.InitWithNewPipeAndPassReceiver());
  4977. network_context->CreateURLLoaderFactory(
  4978. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  4979. mojo::PendingRemote<mojom::URLLoader> loader;
  4980. TestURLLoaderClient client;
  4981. loader_factory->CreateLoaderAndStart(
  4982. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  4983. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  4984. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  4985. header_client.WaitForOnBeforeSendHeaders();
  4986. header_client.CallOnBeforeSendHeadersCallback();
  4987. header_client.WaitForOnHeadersReceived();
  4988. header_client.CallOnHeadersReceivedCallback();
  4989. client.RunUntilComplete();
  4990. EXPECT_EQ(client.completion_status().error_code, net::OK);
  4991. // Make sure request header was modified. The value will be in the body
  4992. // since we used the /echoheader endpoint.
  4993. std::string response;
  4994. EXPECT_TRUE(
  4995. mojo::BlockingCopyToString(client.response_body_release(), &response));
  4996. EXPECT_EQ(response, "bar");
  4997. // Make sure response header was modified.
  4998. EXPECT_TRUE(client.response_head()->headers->HasHeaderValue("baz", "qux"));
  4999. }
  5000. // Test destroying the mojom::URLLoader after the OnBeforeSendHeaders event and
  5001. // then calling the OnBeforeSendHeadersCallback.
  5002. TEST_F(NetworkContextTest, HangingHeaderClientAbortDuringOnBeforeSendHeaders) {
  5003. net::EmbeddedTestServer test_server;
  5004. net::test_server::RegisterDefaultHandlers(&test_server);
  5005. ASSERT_TRUE(test_server.Start());
  5006. std::unique_ptr<NetworkContext> network_context =
  5007. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5008. ResourceRequest request;
  5009. request.url = test_server.GetURL("/echoheader?foo");
  5010. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  5011. mojom::URLLoaderFactoryParamsPtr params =
  5012. mojom::URLLoaderFactoryParams::New();
  5013. params->process_id = mojom::kBrowserProcessId;
  5014. params->is_corb_enabled = false;
  5015. HangingTestURLLoaderHeaderClient header_client(
  5016. params->header_client.InitWithNewPipeAndPassReceiver());
  5017. network_context->CreateURLLoaderFactory(
  5018. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  5019. mojo::PendingRemote<mojom::URLLoader> loader;
  5020. TestURLLoaderClient client;
  5021. loader_factory->CreateLoaderAndStart(
  5022. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  5023. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  5024. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5025. header_client.WaitForOnBeforeSendHeaders();
  5026. loader.reset();
  5027. // Ensure the loader is destroyed before the callback is run.
  5028. base::RunLoop().RunUntilIdle();
  5029. header_client.CallOnBeforeSendHeadersCallback();
  5030. client.RunUntilComplete();
  5031. EXPECT_EQ(client.completion_status().error_code, net::ERR_ABORTED);
  5032. }
  5033. // Test destroying the mojom::URLLoader after the OnHeadersReceived event and
  5034. // then calling the OnHeadersReceivedCallback.
  5035. TEST_F(NetworkContextTest, HangingHeaderClientAbortDuringOnHeadersReceived) {
  5036. net::EmbeddedTestServer test_server;
  5037. net::test_server::RegisterDefaultHandlers(&test_server);
  5038. ASSERT_TRUE(test_server.Start());
  5039. std::unique_ptr<NetworkContext> network_context =
  5040. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5041. ResourceRequest request;
  5042. request.url = test_server.GetURL("/echoheader?foo");
  5043. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  5044. mojom::URLLoaderFactoryParamsPtr params =
  5045. mojom::URLLoaderFactoryParams::New();
  5046. params->process_id = mojom::kBrowserProcessId;
  5047. params->is_corb_enabled = false;
  5048. HangingTestURLLoaderHeaderClient header_client(
  5049. params->header_client.InitWithNewPipeAndPassReceiver());
  5050. network_context->CreateURLLoaderFactory(
  5051. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  5052. mojo::PendingRemote<mojom::URLLoader> loader;
  5053. TestURLLoaderClient client;
  5054. loader_factory->CreateLoaderAndStart(
  5055. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  5056. mojom::kURLLoadOptionUseHeaderClient, request, client.CreateRemote(),
  5057. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5058. header_client.WaitForOnBeforeSendHeaders();
  5059. header_client.CallOnBeforeSendHeadersCallback();
  5060. header_client.WaitForOnHeadersReceived();
  5061. loader.reset();
  5062. // Ensure the loader is destroyed before the callback is run.
  5063. base::RunLoop().RunUntilIdle();
  5064. header_client.CallOnHeadersReceivedCallback();
  5065. client.RunUntilComplete();
  5066. EXPECT_EQ(client.completion_status().error_code, net::ERR_ABORTED);
  5067. }
  5068. // Custom proxy does not apply to localhost, so resolve kMockHost to localhost,
  5069. // and use that instead.
  5070. class NetworkContextMockHostTest : public NetworkContextTest {
  5071. public:
  5072. NetworkContextMockHostTest() {
  5073. net::MockHostResolverBase::RuleResolver rules;
  5074. rules.AddRule(kMockHost, "127.0.0.1");
  5075. network_service_->set_host_resolver_factory_for_testing(
  5076. std::make_unique<net::MockHostResolverFactory>(std::move(rules)));
  5077. }
  5078. protected:
  5079. GURL GetURLWithMockHost(const net::EmbeddedTestServer& server,
  5080. const std::string& relative_url) {
  5081. GURL server_base_url = server.base_url();
  5082. GURL base_url =
  5083. GURL(base::StrCat({server_base_url.scheme(), "://", kMockHost, ":",
  5084. server_base_url.port()}));
  5085. EXPECT_TRUE(base_url.is_valid()) << base_url.possibly_invalid_spec();
  5086. return base_url.Resolve(relative_url);
  5087. }
  5088. net::ProxyServer ConvertToProxyServer(const net::EmbeddedTestServer& server) {
  5089. std::string base_url = server.base_url().spec();
  5090. // Remove slash from URL.
  5091. base_url.pop_back();
  5092. auto proxy_server =
  5093. net::ProxyUriToProxyServer(base_url, net::ProxyServer::SCHEME_HTTP);
  5094. EXPECT_TRUE(proxy_server.is_valid()) << base_url;
  5095. return proxy_server;
  5096. }
  5097. };
  5098. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
  5099. // Flaky crashes on Linux: https://crbug.com/1115201
  5100. #define MAYBE_CustomProxyUsesSpecifiedProxyList \
  5101. DISABLED_CustomProxyUsesSpecifiedProxyList
  5102. #else
  5103. #define MAYBE_CustomProxyUsesSpecifiedProxyList \
  5104. CustomProxyUsesSpecifiedProxyList
  5105. #endif
  5106. TEST_F(NetworkContextMockHostTest, MAYBE_CustomProxyUsesSpecifiedProxyList) {
  5107. net::EmbeddedTestServer proxy_test_server;
  5108. net::test_server::RegisterDefaultHandlers(&proxy_test_server);
  5109. ASSERT_TRUE(proxy_test_server.Start());
  5110. mojo::Remote<mojom::CustomProxyConfigClient> proxy_config_client;
  5111. mojom::NetworkContextParamsPtr context_params =
  5112. CreateNetworkContextParamsForTesting();
  5113. context_params->custom_proxy_config_client_receiver =
  5114. proxy_config_client.BindNewPipeAndPassReceiver();
  5115. std::unique_ptr<NetworkContext> network_context =
  5116. CreateContextWithParams(std::move(context_params));
  5117. auto config = mojom::CustomProxyConfig::New();
  5118. config->rules.ParseFromString(
  5119. "http=" +
  5120. net::ProxyServerToProxyUri(ConvertToProxyServer(proxy_test_server)));
  5121. base::RunLoop loop;
  5122. proxy_config_client->OnCustomProxyConfigUpdated(std::move(config),
  5123. loop.QuitClosure());
  5124. loop.Run();
  5125. ResourceRequest request;
  5126. request.url = GURL("http://does.not.resolve/echo");
  5127. std::unique_ptr<TestURLLoaderClient> client =
  5128. FetchRequest(request, network_context.get());
  5129. std::string response;
  5130. EXPECT_TRUE(
  5131. mojo::BlockingCopyToString(client->response_body_release(), &response));
  5132. // |invalid_server| has no handlers set up so would return an empty response.
  5133. EXPECT_EQ(response, "Echo");
  5134. EXPECT_EQ(client->response_head()->proxy_server,
  5135. ConvertToProxyServer(proxy_test_server));
  5136. }
  5137. TEST_F(NetworkContextTest, MaximumCount) {
  5138. net::EmbeddedTestServer test_server;
  5139. test_server.AddDefaultHandlers(
  5140. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5141. const char kPath1[] = "/foobar";
  5142. const char kPath2[] = "/hung";
  5143. const char kPath3[] = "/hello.html";
  5144. net::test_server::ControllableHttpResponse controllable_response1(
  5145. &test_server, kPath1);
  5146. ASSERT_TRUE(test_server.Start());
  5147. std::unique_ptr<NetworkContext> network_context =
  5148. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5149. network_context->set_max_loaders_per_process_for_testing(2);
  5150. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  5151. mojom::URLLoaderFactoryParamsPtr params =
  5152. mojom::URLLoaderFactoryParams::New();
  5153. params->process_id = mojom::kBrowserProcessId;
  5154. params->is_corb_enabled = false;
  5155. network_context->CreateURLLoaderFactory(
  5156. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  5157. ResourceRequest request;
  5158. request.url = test_server.GetURL(kPath1);
  5159. auto client1 = std::make_unique<TestURLLoaderClient>();
  5160. mojo::PendingRemote<mojom::URLLoader> loader1;
  5161. loader_factory->CreateLoaderAndStart(
  5162. loader1.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  5163. 0 /* options */, request, client1->CreateRemote(),
  5164. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5165. request.url = test_server.GetURL(kPath2);
  5166. auto client2 = std::make_unique<TestURLLoaderClient>();
  5167. mojo::PendingRemote<mojom::URLLoader> loader2;
  5168. loader_factory->CreateLoaderAndStart(
  5169. loader2.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  5170. 0 /* options */, request, client2->CreateRemote(),
  5171. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5172. // A third request should fail, since the first two are outstanding and the
  5173. // limit is 2.
  5174. request.url = test_server.GetURL(kPath3);
  5175. auto client3 = std::make_unique<TestURLLoaderClient>();
  5176. mojo::Remote<mojom::URLLoader> loader3;
  5177. loader_factory->CreateLoaderAndStart(
  5178. loader3.BindNewPipeAndPassReceiver(), 0 /* request_id */, 0 /* options */,
  5179. request, client3->CreateRemote(),
  5180. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5181. client3->RunUntilComplete();
  5182. ASSERT_EQ(client3->completion_status().error_code,
  5183. net::ERR_INSUFFICIENT_RESOURCES);
  5184. // Complete the first request and try the third again.
  5185. controllable_response1.WaitForRequest();
  5186. controllable_response1.Send("HTTP/1.1 200 OK\r\n");
  5187. controllable_response1.Done();
  5188. client1->RunUntilComplete();
  5189. ASSERT_EQ(client1->completion_status().error_code, net::OK);
  5190. client3 = std::make_unique<TestURLLoaderClient>();
  5191. loader3.reset();
  5192. loader_factory->CreateLoaderAndStart(
  5193. loader3.BindNewPipeAndPassReceiver(), 0 /* request_id */, 0 /* options */,
  5194. request, client3->CreateRemote(),
  5195. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5196. client3->RunUntilComplete();
  5197. ASSERT_EQ(client3->completion_status().error_code, net::OK);
  5198. }
  5199. TEST_F(NetworkContextTest, AllowAllCookies) {
  5200. net::test_server::EmbeddedTestServer test_server(
  5201. net::test_server::EmbeddedTestServer::TYPE_HTTPS);
  5202. test_server.AddDefaultHandlers(
  5203. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5204. ASSERT_TRUE(test_server.Start());
  5205. GURL server_url = test_server.GetURL("/echoheader?Cookie");
  5206. GURL first_party_url(server_url);
  5207. GURL third_party_url("http://www.some.other.origin.test/");
  5208. std::unique_ptr<NetworkContext> network_context =
  5209. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5210. EXPECT_TRUE(
  5211. SetCookieHelper(network_context.get(), server_url, "TestCookie", "1"));
  5212. int url_loader_options = mojom::kURLLoadOptionNone;
  5213. ResourceRequest first_party_request;
  5214. first_party_request.url = server_url;
  5215. first_party_request.site_for_cookies =
  5216. net::SiteForCookies::FromUrl(first_party_url);
  5217. std::unique_ptr<TestURLLoaderClient> client = FetchRequest(
  5218. first_party_request, network_context.get(), url_loader_options);
  5219. std::string response_body;
  5220. ASSERT_TRUE(client->response_body().is_valid());
  5221. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5222. &response_body));
  5223. EXPECT_EQ("TestCookie=1", response_body);
  5224. ResourceRequest third_party_request;
  5225. third_party_request.url = server_url;
  5226. third_party_request.site_for_cookies =
  5227. net::SiteForCookies::FromUrl(third_party_url);
  5228. client = FetchRequest(third_party_request, network_context.get(),
  5229. url_loader_options);
  5230. ASSERT_TRUE(client->response_body().is_valid());
  5231. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5232. &response_body));
  5233. EXPECT_EQ("TestCookie=1", response_body);
  5234. }
  5235. TEST_F(NetworkContextTest, BlockThirdPartyCookies) {
  5236. net::test_server::EmbeddedTestServer test_server(
  5237. net::test_server::EmbeddedTestServer::TYPE_HTTPS);
  5238. test_server.AddDefaultHandlers(
  5239. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5240. ASSERT_TRUE(test_server.Start());
  5241. GURL server_url = test_server.GetURL("/echoheader?Cookie");
  5242. GURL first_party_url(server_url);
  5243. GURL third_party_url("http://www.some.other.origin.test/");
  5244. std::unique_ptr<NetworkContext> network_context =
  5245. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5246. EXPECT_TRUE(
  5247. SetCookieHelper(network_context.get(), server_url, "TestCookie", "1"));
  5248. int url_loader_options = mojom::kURLLoadOptionBlockThirdPartyCookies;
  5249. ResourceRequest first_party_request;
  5250. first_party_request.url = server_url;
  5251. first_party_request.site_for_cookies =
  5252. net::SiteForCookies::FromUrl(first_party_url);
  5253. std::unique_ptr<TestURLLoaderClient> client = FetchRequest(
  5254. first_party_request, network_context.get(), url_loader_options);
  5255. std::string response_body;
  5256. ASSERT_TRUE(client->response_body().is_valid());
  5257. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5258. &response_body));
  5259. EXPECT_EQ("TestCookie=1", response_body);
  5260. ResourceRequest third_party_request;
  5261. third_party_request.url = server_url;
  5262. third_party_request.site_for_cookies =
  5263. net::SiteForCookies::FromUrl(third_party_url);
  5264. client = FetchRequest(third_party_request, network_context.get(),
  5265. url_loader_options);
  5266. ASSERT_TRUE(client->response_body().is_valid());
  5267. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5268. &response_body));
  5269. EXPECT_EQ("None", response_body);
  5270. }
  5271. TEST_F(NetworkContextTest, BlockAllCookies) {
  5272. net::test_server::EmbeddedTestServer test_server(
  5273. net::test_server::EmbeddedTestServer::TYPE_HTTPS);
  5274. test_server.AddDefaultHandlers(
  5275. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5276. ASSERT_TRUE(test_server.Start());
  5277. GURL server_url = test_server.GetURL("/echoheader?Cookie");
  5278. GURL first_party_url(server_url);
  5279. GURL third_party_url("http://www.some.other.origin.test/");
  5280. std::unique_ptr<NetworkContext> network_context =
  5281. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5282. EXPECT_TRUE(
  5283. SetCookieHelper(network_context.get(), server_url, "TestCookie", "1"));
  5284. int url_loader_options = mojom::kURLLoadOptionBlockAllCookies;
  5285. ResourceRequest first_party_request;
  5286. first_party_request.url = server_url;
  5287. first_party_request.site_for_cookies =
  5288. net::SiteForCookies::FromUrl(first_party_url);
  5289. std::unique_ptr<TestURLLoaderClient> client = FetchRequest(
  5290. first_party_request, network_context.get(), url_loader_options);
  5291. std::string response_body;
  5292. ASSERT_TRUE(client->response_body().is_valid());
  5293. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5294. &response_body));
  5295. EXPECT_EQ("None", response_body);
  5296. ResourceRequest third_party_request;
  5297. third_party_request.url = server_url;
  5298. third_party_request.site_for_cookies =
  5299. net::SiteForCookies::FromUrl(third_party_url);
  5300. client = FetchRequest(third_party_request, network_context.get(),
  5301. url_loader_options);
  5302. ASSERT_TRUE(client->response_body().is_valid());
  5303. EXPECT_TRUE(mojo::BlockingCopyToString(client->response_body_release(),
  5304. &response_body));
  5305. EXPECT_EQ("None", response_body);
  5306. }
  5307. #if BUILDFLAG(IS_CT_SUPPORTED)
  5308. TEST_F(NetworkContextTest, CertificateTransparencyConfig) {
  5309. // Configure CT logs in network service.
  5310. std::vector<network::mojom::CTLogInfoPtr> log_list_mojo;
  5311. // The log public keys do not matter for the test, so invalid keys are used.
  5312. // However, because the log IDs are derived from the SHA-256 hash of the log
  5313. // key, the log keys are generated such that qualified logs are in the form
  5314. // of four digits (e.g. "0000", "1111"), while disqualified logs are in the
  5315. // form of four letters (e.g. "AAAA", "BBBB").
  5316. for (int i = 0; i < 6; ++i) {
  5317. network::mojom::CTLogInfoPtr log_info = network::mojom::CTLogInfo::New();
  5318. // Shift to ASCII '0' (0x30)
  5319. log_info->public_key = std::string(4, 0x30 + static_cast<char>(i));
  5320. log_info->name = std::string(4, 0x30 + static_cast<char>(i));
  5321. log_info->operated_by_google = i % 2;
  5322. if (log_info->operated_by_google) {
  5323. log_info->current_operator = "Google";
  5324. } else {
  5325. log_info->current_operator = "Not Google";
  5326. }
  5327. log_list_mojo.push_back(std::move(log_info));
  5328. }
  5329. for (int i = 0; i < 3; ++i) {
  5330. network::mojom::CTLogInfoPtr log_info = network::mojom::CTLogInfo::New();
  5331. // Shift to ASCII 'A' (0x41)
  5332. log_info->public_key = std::string(4, 0x41 + static_cast<char>(i));
  5333. log_info->name = std::string(4, 0x41 + static_cast<char>(i));
  5334. log_info->operated_by_google = false;
  5335. log_info->disqualified_at = base::Time::FromTimeT(i);
  5336. log_info->current_operator = "Not Google Either";
  5337. log_list_mojo.push_back(std::move(log_info));
  5338. }
  5339. base::RunLoop run_loop;
  5340. network_service()->UpdateCtLogList(std::move(log_list_mojo),
  5341. base::Time::Now(), run_loop.QuitClosure());
  5342. run_loop.Run();
  5343. // Configure CT params in network context.
  5344. mojom::NetworkContextParamsPtr params =
  5345. CreateNetworkContextParamsForTesting();
  5346. params->enforce_chrome_ct_policy = true;
  5347. std::unique_ptr<NetworkContext> network_context =
  5348. CreateContextWithParams(std::move(params));
  5349. net::CTPolicyEnforcer* request_enforcer =
  5350. network_context->url_request_context()->ct_policy_enforcer();
  5351. ASSERT_TRUE(request_enforcer);
  5352. // Completely unsafe if |enforce_chrome_ct_policy| is false.
  5353. certificate_transparency::ChromeCTPolicyEnforcer* policy_enforcer =
  5354. reinterpret_cast<certificate_transparency::ChromeCTPolicyEnforcer*>(
  5355. request_enforcer);
  5356. EXPECT_TRUE(std::is_sorted(
  5357. policy_enforcer->operated_by_google_logs_for_testing().begin(),
  5358. policy_enforcer->operated_by_google_logs_for_testing().end()));
  5359. EXPECT_TRUE(
  5360. std::is_sorted(policy_enforcer->disqualified_logs_for_testing().begin(),
  5361. policy_enforcer->disqualified_logs_for_testing().end()));
  5362. EXPECT_THAT(
  5363. policy_enforcer->operated_by_google_logs_for_testing(),
  5364. ::testing::UnorderedElementsAreArray({crypto::SHA256HashString("1111"),
  5365. crypto::SHA256HashString("3333"),
  5366. crypto::SHA256HashString("5555")}));
  5367. EXPECT_THAT(policy_enforcer->disqualified_logs_for_testing(),
  5368. ::testing::UnorderedElementsAre(
  5369. ::testing::Pair(crypto::SHA256HashString("AAAA"),
  5370. base::Time::FromTimeT(0)),
  5371. ::testing::Pair(crypto::SHA256HashString("BBBB"),
  5372. base::Time::FromTimeT(1)),
  5373. ::testing::Pair(crypto::SHA256HashString("CCCC"),
  5374. base::Time::FromTimeT(2))));
  5375. std::map<std::string, certificate_transparency::OperatorHistoryEntry>
  5376. operator_history = policy_enforcer->operator_history_for_testing();
  5377. for (auto log : policy_enforcer->operated_by_google_logs_for_testing()) {
  5378. EXPECT_EQ(operator_history[log].current_operator_, "Google");
  5379. EXPECT_TRUE(operator_history[log].previous_operators_.empty());
  5380. }
  5381. for (auto log : policy_enforcer->disqualified_logs_for_testing()) {
  5382. EXPECT_EQ(operator_history[log.first].current_operator_,
  5383. "Not Google Either");
  5384. EXPECT_TRUE(operator_history[log.first].previous_operators_.empty());
  5385. }
  5386. }
  5387. TEST_F(NetworkContextTest, CertificateTransparencyConfigWithOperatorSwitches) {
  5388. // Configure CT logs in network service.
  5389. std::vector<network::mojom::CTLogInfoPtr> log_list_mojo;
  5390. // The log public keys do not matter for the test, so invalid keys are used.
  5391. // However, because the log IDs are derived from the SHA-256 hash of the log
  5392. // key, the log keys are generated such that the log that never switched
  5393. // operator is "0000", while the one that did is "AAAA".
  5394. network::mojom::CTLogInfoPtr log_info = network::mojom::CTLogInfo::New();
  5395. // Shift to ASCII '0' (0x30)
  5396. log_info->public_key = std::string(4, 0x30);
  5397. log_info->name = std::string(4, 0x30);
  5398. log_info->current_operator = "Forever Operator";
  5399. log_list_mojo.push_back(std::move(log_info));
  5400. log_info = network::mojom::CTLogInfo::New();
  5401. // Shift to ASCII 'A' (0x41)
  5402. log_info->public_key = std::string(4, 0x41);
  5403. log_info->name = std::string(4, 0x41);
  5404. log_info->current_operator = "Changed Operator";
  5405. for (int i = 0; i < 3; i++) {
  5406. network::mojom::PreviousOperatorEntryPtr previous_operator =
  5407. network::mojom::PreviousOperatorEntry::New();
  5408. previous_operator->name = "Operator " + base::NumberToString(i);
  5409. previous_operator->end_time = base::Time::FromTimeT(i);
  5410. log_info->previous_operators.push_back(std::move(previous_operator));
  5411. }
  5412. log_list_mojo.push_back(std::move(log_info));
  5413. base::RunLoop run_loop;
  5414. network_service()->UpdateCtLogList(std::move(log_list_mojo),
  5415. base::Time::Now(), run_loop.QuitClosure());
  5416. run_loop.Run();
  5417. // Configure CT params in network context.
  5418. mojom::NetworkContextParamsPtr params =
  5419. CreateNetworkContextParamsForTesting();
  5420. params->enforce_chrome_ct_policy = true;
  5421. std::unique_ptr<NetworkContext> network_context =
  5422. CreateContextWithParams(std::move(params));
  5423. net::CTPolicyEnforcer* request_enforcer =
  5424. network_context->url_request_context()->ct_policy_enforcer();
  5425. ASSERT_TRUE(request_enforcer);
  5426. // Completely unsafe if |enforce_chrome_ct_policy| is false.
  5427. certificate_transparency::ChromeCTPolicyEnforcer* policy_enforcer =
  5428. reinterpret_cast<certificate_transparency::ChromeCTPolicyEnforcer*>(
  5429. request_enforcer);
  5430. std::map<std::string, certificate_transparency::OperatorHistoryEntry>
  5431. operator_history = policy_enforcer->operator_history_for_testing();
  5432. EXPECT_EQ(
  5433. operator_history[crypto::SHA256HashString("0000")].current_operator_,
  5434. "Forever Operator");
  5435. EXPECT_TRUE(operator_history[crypto::SHA256HashString("0000")]
  5436. .previous_operators_.empty());
  5437. EXPECT_EQ(
  5438. operator_history[crypto::SHA256HashString("AAAA")].current_operator_,
  5439. "Changed Operator");
  5440. EXPECT_THAT(
  5441. operator_history[crypto::SHA256HashString("AAAA")].previous_operators_,
  5442. ::testing::ElementsAre(
  5443. ::testing::Pair("Operator 0", base::Time::FromTimeT(0)),
  5444. ::testing::Pair("Operator 1", base::Time::FromTimeT(1)),
  5445. ::testing::Pair("Operator 2", base::Time::FromTimeT(2))));
  5446. }
  5447. #endif
  5448. TEST_F(NetworkContextTest, AddHttpAuthCacheEntry) {
  5449. std::unique_ptr<NetworkContext> network_context =
  5450. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5451. net::HttpAuthCache* cache = network_context->url_request_context()
  5452. ->http_transaction_factory()
  5453. ->GetSession()
  5454. ->http_auth_cache();
  5455. ASSERT_TRUE(cache);
  5456. // |key_server_entries_by_network_isolation_key| should be disabled by
  5457. // default, so the passed in NetworkIsolationKeys don't matter.
  5458. EXPECT_FALSE(cache->key_server_entries_by_network_isolation_key());
  5459. // Add an AUTH_SERVER cache entry.
  5460. url::SchemeHostPort scheme_host_port(GURL("http://example.test/"));
  5461. net::AuthChallengeInfo challenge;
  5462. challenge.is_proxy = false;
  5463. challenge.challenger = scheme_host_port;
  5464. challenge.scheme = "basic";
  5465. challenge.realm = "testrealm";
  5466. const char16_t kUsername[] = u"test_user";
  5467. const char16_t kPassword[] = u"test_pass";
  5468. ASSERT_FALSE(cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  5469. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5470. net::NetworkIsolationKey()));
  5471. base::RunLoop run_loop;
  5472. network_context->AddAuthCacheEntry(challenge, net::NetworkIsolationKey(),
  5473. net::AuthCredentials(kUsername, kPassword),
  5474. run_loop.QuitClosure());
  5475. run_loop.Run();
  5476. net::HttpAuthCache::Entry* entry = cache->Lookup(
  5477. scheme_host_port, net::HttpAuth::AUTH_SERVER, challenge.realm,
  5478. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey());
  5479. ASSERT_TRUE(entry);
  5480. EXPECT_EQ(scheme_host_port, entry->scheme_host_port());
  5481. EXPECT_EQ(challenge.realm, entry->realm());
  5482. EXPECT_EQ(net::HttpAuth::StringToScheme(challenge.scheme), entry->scheme());
  5483. EXPECT_EQ(kUsername, entry->credentials().username());
  5484. EXPECT_EQ(kPassword, entry->credentials().password());
  5485. // Entry should only have been added for server auth.
  5486. EXPECT_FALSE(cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_PROXY,
  5487. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5488. net::NetworkIsolationKey()));
  5489. // Add an AUTH_PROXY cache entry.
  5490. url::SchemeHostPort proxy_scheme_host_port(GURL("http://proxy.test/"));
  5491. challenge.is_proxy = true;
  5492. challenge.challenger = proxy_scheme_host_port;
  5493. const char16_t kProxyUsername[] = u"test_proxy_user";
  5494. const char16_t kProxyPassword[] = u"test_proxy_pass";
  5495. ASSERT_FALSE(cache->Lookup(proxy_scheme_host_port, net::HttpAuth::AUTH_PROXY,
  5496. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5497. net::NetworkIsolationKey()));
  5498. base::RunLoop run_loop2;
  5499. network_context->AddAuthCacheEntry(
  5500. challenge, net::NetworkIsolationKey(),
  5501. net::AuthCredentials(kProxyUsername, kProxyPassword),
  5502. run_loop2.QuitClosure());
  5503. run_loop2.Run();
  5504. entry = cache->Lookup(proxy_scheme_host_port, net::HttpAuth::AUTH_PROXY,
  5505. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5506. net::NetworkIsolationKey());
  5507. ASSERT_TRUE(entry);
  5508. EXPECT_EQ(proxy_scheme_host_port, entry->scheme_host_port());
  5509. EXPECT_EQ(challenge.realm, entry->realm());
  5510. EXPECT_EQ(net::HttpAuth::StringToScheme(challenge.scheme), entry->scheme());
  5511. EXPECT_EQ(kProxyUsername, entry->credentials().username());
  5512. EXPECT_EQ(kProxyPassword, entry->credentials().password());
  5513. // Entry should only have been added for proxy auth.
  5514. EXPECT_FALSE(cache->Lookup(proxy_scheme_host_port, net::HttpAuth::AUTH_SERVER,
  5515. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5516. net::NetworkIsolationKey()));
  5517. }
  5518. TEST_F(NetworkContextTest, AddHttpAuthCacheEntryWithNetworkIsolationKey) {
  5519. std::unique_ptr<NetworkContext> network_context =
  5520. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5521. network_context->SetSplitAuthCacheByNetworkIsolationKey(true);
  5522. net::HttpAuthCache* cache = network_context->url_request_context()
  5523. ->http_transaction_factory()
  5524. ->GetSession()
  5525. ->http_auth_cache();
  5526. ASSERT_TRUE(cache);
  5527. // If this isn't true, the rest of this test is pretty meaningless.
  5528. ASSERT_TRUE(cache->key_server_entries_by_network_isolation_key());
  5529. // Add an AUTH_SERVER cache entry.
  5530. url::Origin origin = url::Origin::Create(GURL("http://example.test/"));
  5531. url::SchemeHostPort scheme_host_port =
  5532. origin.GetTupleOrPrecursorTupleIfOpaque();
  5533. net::NetworkIsolationKey network_isolation_key(origin, origin);
  5534. net::AuthChallengeInfo challenge;
  5535. challenge.is_proxy = false;
  5536. challenge.challenger = scheme_host_port;
  5537. challenge.scheme = "basic";
  5538. challenge.realm = "testrealm";
  5539. const char16_t kUsername[] = u"test_user";
  5540. const char16_t kPassword[] = u"test_pass";
  5541. ASSERT_FALSE(cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  5542. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5543. network_isolation_key));
  5544. base::RunLoop run_loop;
  5545. network_context->AddAuthCacheEntry(challenge, network_isolation_key,
  5546. net::AuthCredentials(kUsername, kPassword),
  5547. run_loop.QuitClosure());
  5548. run_loop.Run();
  5549. net::HttpAuthCache::Entry* entry = cache->Lookup(
  5550. scheme_host_port, net::HttpAuth::AUTH_SERVER, challenge.realm,
  5551. net::HttpAuth::AUTH_SCHEME_BASIC, network_isolation_key);
  5552. ASSERT_TRUE(entry);
  5553. EXPECT_EQ(scheme_host_port, entry->scheme_host_port());
  5554. EXPECT_EQ(challenge.realm, entry->realm());
  5555. EXPECT_EQ(net::HttpAuth::StringToScheme(challenge.scheme), entry->scheme());
  5556. EXPECT_EQ(kUsername, entry->credentials().username());
  5557. EXPECT_EQ(kPassword, entry->credentials().password());
  5558. // Entry should only be accessibly when using the correct NetworkIsolationKey.
  5559. EXPECT_FALSE(cache->Lookup(scheme_host_port, net::HttpAuth::AUTH_SERVER,
  5560. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5561. net::NetworkIsolationKey()));
  5562. }
  5563. TEST_F(NetworkContextTest, CopyHttpAuthCacheProxyEntries) {
  5564. const url::SchemeHostPort kSchemeHostPort(GURL("http://foo.com"));
  5565. std::unique_ptr<NetworkContext> network_context1 =
  5566. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5567. net::AuthChallengeInfo challenge;
  5568. challenge.is_proxy = true;
  5569. challenge.challenger = kSchemeHostPort;
  5570. challenge.scheme = "basic";
  5571. challenge.realm = "testrealm";
  5572. const char16_t kProxyUsername[] = u"proxy_user";
  5573. const char16_t kProxyPassword[] = u"proxy_pass";
  5574. base::RunLoop run_loop1;
  5575. network_context1->AddAuthCacheEntry(
  5576. challenge, net::NetworkIsolationKey(),
  5577. net::AuthCredentials(kProxyUsername, kProxyPassword),
  5578. run_loop1.QuitClosure());
  5579. run_loop1.Run();
  5580. challenge.is_proxy = false;
  5581. const char16_t kServerUsername[] = u"server_user";
  5582. const char16_t kServerPassword[] = u"server_pass";
  5583. base::RunLoop run_loop2;
  5584. network_context1->AddAuthCacheEntry(
  5585. challenge, net::NetworkIsolationKey(),
  5586. net::AuthCredentials(kServerUsername, kServerPassword),
  5587. run_loop2.QuitClosure());
  5588. run_loop2.Run();
  5589. base::UnguessableToken token;
  5590. base::RunLoop run_loop3;
  5591. network_context1->SaveHttpAuthCacheProxyEntries(base::BindLambdaForTesting(
  5592. [&](const base::UnguessableToken& returned_token) {
  5593. token = returned_token;
  5594. run_loop3.Quit();
  5595. }));
  5596. run_loop3.Run();
  5597. // Delete first NetworkContext, to make sure saved credentials outlast it.
  5598. network_context1.reset();
  5599. base::RunLoop().RunUntilIdle();
  5600. std::unique_ptr<NetworkContext> network_context2 =
  5601. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5602. base::RunLoop run_loop4;
  5603. network_context2->LoadHttpAuthCacheProxyEntries(token,
  5604. run_loop4.QuitClosure());
  5605. run_loop4.Run();
  5606. // Check cached credentials directly, since there's no API to check proxy
  5607. // credentials.
  5608. net::HttpAuthCache* cache = network_context2->url_request_context()
  5609. ->http_transaction_factory()
  5610. ->GetSession()
  5611. ->http_auth_cache();
  5612. // The server credentials should not have been copied.
  5613. EXPECT_FALSE(cache->Lookup(kSchemeHostPort, net::HttpAuth::AUTH_SERVER,
  5614. challenge.realm, net::HttpAuth::AUTH_SCHEME_BASIC,
  5615. net::NetworkIsolationKey()));
  5616. net::HttpAuthCache::Entry* entry = cache->Lookup(
  5617. kSchemeHostPort, net::HttpAuth::AUTH_PROXY, challenge.realm,
  5618. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey());
  5619. ASSERT_TRUE(entry);
  5620. EXPECT_EQ(kProxyUsername, entry->credentials().username());
  5621. EXPECT_EQ(kProxyPassword, entry->credentials().password());
  5622. }
  5623. TEST_F(NetworkContextTest, SplitAuthCacheByNetworkIsolationKey) {
  5624. const url::SchemeHostPort kSchemeHostPort(GURL("http://foo.com"));
  5625. std::unique_ptr<NetworkContext> network_context =
  5626. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5627. net::HttpAuthCache* cache = network_context->url_request_context()
  5628. ->http_transaction_factory()
  5629. ->GetSession()
  5630. ->http_auth_cache();
  5631. EXPECT_FALSE(cache->key_server_entries_by_network_isolation_key());
  5632. // Add proxy credentials, which should never be deleted.
  5633. net::AuthChallengeInfo challenge;
  5634. challenge.is_proxy = true;
  5635. challenge.challenger = kSchemeHostPort;
  5636. challenge.scheme = "basic";
  5637. challenge.realm = "testrealm";
  5638. const char16_t kProxyUsername[] = u"proxy_user";
  5639. const char16_t kProxyPassword[] = u"proxy_pass";
  5640. base::RunLoop run_loop1;
  5641. network_context->AddAuthCacheEntry(
  5642. challenge, net::NetworkIsolationKey(),
  5643. net::AuthCredentials(kProxyUsername, kProxyPassword),
  5644. run_loop1.QuitClosure());
  5645. run_loop1.Run();
  5646. // Set up challenge to add server credentials.
  5647. challenge.is_proxy = false;
  5648. for (bool set_split_cache_by_network_isolation_key : {true, false}) {
  5649. // In each loop iteration, the setting should change, which should clear
  5650. // server credentials.
  5651. EXPECT_NE(set_split_cache_by_network_isolation_key,
  5652. cache->key_server_entries_by_network_isolation_key());
  5653. // Add server credentials.
  5654. const char16_t kServerUsername[] = u"server_user";
  5655. const char16_t kServerPassword[] = u"server_pass";
  5656. base::RunLoop run_loop2;
  5657. network_context->AddAuthCacheEntry(
  5658. challenge, net::NetworkIsolationKey(),
  5659. net::AuthCredentials(kServerUsername, kServerPassword),
  5660. run_loop2.QuitClosure());
  5661. run_loop2.Run();
  5662. // Toggle setting.
  5663. network_context->SetSplitAuthCacheByNetworkIsolationKey(
  5664. set_split_cache_by_network_isolation_key);
  5665. EXPECT_EQ(set_split_cache_by_network_isolation_key,
  5666. cache->key_server_entries_by_network_isolation_key());
  5667. // The server credentials should have been deleted.
  5668. EXPECT_FALSE(cache->Lookup(
  5669. kSchemeHostPort, net::HttpAuth::AUTH_SERVER, challenge.realm,
  5670. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey()));
  5671. // The proxy credentials should still be in the cache.
  5672. net::HttpAuthCache::Entry* entry = cache->Lookup(
  5673. kSchemeHostPort, net::HttpAuth::AUTH_PROXY, challenge.realm,
  5674. net::HttpAuth::AUTH_SCHEME_BASIC, net::NetworkIsolationKey());
  5675. ASSERT_TRUE(entry);
  5676. EXPECT_EQ(kProxyUsername, entry->credentials().username());
  5677. EXPECT_EQ(kProxyPassword, entry->credentials().password());
  5678. }
  5679. }
  5680. TEST_F(NetworkContextTest, HSTSPolicyBypassList) {
  5681. // The default test preload list includes "example" as a preloaded TLD
  5682. // (including subdomains).
  5683. net::ScopedTransportSecurityStateSource scoped_security_state_source;
  5684. mojom::NetworkContextParamsPtr params =
  5685. CreateNetworkContextParamsForTesting();
  5686. params->hsts_policy_bypass_list.push_back("example");
  5687. std::unique_ptr<NetworkContext> network_context =
  5688. CreateContextWithParams(std::move(params));
  5689. net::TransportSecurityState* transport_security_state =
  5690. network_context->url_request_context()->transport_security_state();
  5691. // With the policy set, example should no longer upgrade to HTTPS.
  5692. EXPECT_FALSE(transport_security_state->ShouldUpgradeToSSL("example"));
  5693. // But the policy shouldn't apply to subdomains.
  5694. EXPECT_TRUE(transport_security_state->ShouldUpgradeToSSL("sub.example"));
  5695. }
  5696. TEST_F(NetworkContextTest, FactoriesDeletedWhenBindingsCleared) {
  5697. std::unique_ptr<NetworkContext> network_context =
  5698. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5699. auto loader_params = mojom::URLLoaderFactoryParams::New();
  5700. loader_params->process_id = 1;
  5701. mojo::Remote<mojom::URLLoaderFactory> remote1;
  5702. network_context->CreateURLLoaderFactory(remote1.BindNewPipeAndPassReceiver(),
  5703. std::move(loader_params));
  5704. loader_params = mojom::URLLoaderFactoryParams::New();
  5705. loader_params->process_id = 1;
  5706. mojo::Remote<mojom::URLLoaderFactory> remote2;
  5707. network_context->CreateURLLoaderFactory(remote2.BindNewPipeAndPassReceiver(),
  5708. std::move(loader_params));
  5709. // We should have at least 2 loader factories.
  5710. EXPECT_GT(network_context->num_url_loader_factories_for_testing(), 1u);
  5711. network_context->ResetURLLoaderFactories();
  5712. EXPECT_EQ(network_context->num_url_loader_factories_for_testing(), 0u);
  5713. }
  5714. static ResourceRequest CreateResourceRequest(const char* method,
  5715. const GURL& url) {
  5716. ResourceRequest request;
  5717. request.method = std::string(method);
  5718. request.url = url;
  5719. request.request_initiator =
  5720. url::Origin::Create(url); // ensure initiator is set
  5721. return request;
  5722. }
  5723. class NetworkContextSplitCacheTest : public NetworkContextTest {
  5724. protected:
  5725. NetworkContextSplitCacheTest() {
  5726. feature_list_.InitAndEnableFeature(
  5727. net::features::kSplitCacheByNetworkIsolationKey);
  5728. test_server_.AddDefaultHandlers(
  5729. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5730. EXPECT_TRUE(test_server_.Start());
  5731. // Set up a scoped host resolver to access other origins.
  5732. scoped_refptr<net::RuleBasedHostResolverProc> mock_resolver_proc =
  5733. base::MakeRefCounted<net::RuleBasedHostResolverProc>(nullptr);
  5734. mock_resolver_proc->AddRule("*", "127.0.0.1");
  5735. mock_host_resolver_ = std::make_unique<net::ScopedDefaultHostResolverProc>(
  5736. mock_resolver_proc.get());
  5737. mojom::NetworkContextParamsPtr context_params =
  5738. CreateNetworkContextParamsForTesting();
  5739. network_context_ = CreateContextWithParams(std::move(context_params));
  5740. }
  5741. net::EmbeddedTestServer* test_server() { return &test_server_; }
  5742. void LoadAndVerifyCached(const GURL& url,
  5743. const net::IsolationInfo& isolation_info,
  5744. bool was_cached,
  5745. bool expect_redirect = false,
  5746. absl::optional<GURL> new_url = absl::nullopt,
  5747. bool automatically_assign_isolation_info = false) {
  5748. ResourceRequest request = CreateResourceRequest("GET", url);
  5749. request.load_flags |= net::LOAD_SKIP_CACHE_VALIDATION;
  5750. mojo::Remote<mojom::URLLoaderFactory> loader_factory;
  5751. auto params = mojom::URLLoaderFactoryParams::New();
  5752. params->process_id = mojom::kBrowserProcessId;
  5753. params->is_corb_enabled = false;
  5754. if (isolation_info.request_type() ==
  5755. net::IsolationInfo::RequestType::kOther) {
  5756. params->isolation_info = isolation_info;
  5757. } else {
  5758. request.trusted_params = ResourceRequest::TrustedParams();
  5759. request.trusted_params->isolation_info = isolation_info;
  5760. params->is_trusted = true;
  5761. // These params must be individually set, to be consistent with the
  5762. // IsolationInfo if its request type is a main frame navigation.
  5763. // TODO(crbug.com/1172314): Unify these to avoid inconsistencies.
  5764. if (isolation_info.request_type() ==
  5765. net::IsolationInfo::RequestType::kMainFrame) {
  5766. request.is_outermost_main_frame = true;
  5767. request.update_first_party_url_on_redirect = true;
  5768. }
  5769. }
  5770. params->automatically_assign_isolation_info =
  5771. automatically_assign_isolation_info;
  5772. request.site_for_cookies = isolation_info.site_for_cookies();
  5773. network_context_->CreateURLLoaderFactory(
  5774. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  5775. auto client = std::make_unique<TestURLLoaderClient>();
  5776. mojo::Remote<mojom::URLLoader> loader;
  5777. loader_factory->CreateLoaderAndStart(
  5778. loader.BindNewPipeAndPassReceiver(), 0 /* request_id */,
  5779. mojom::kURLLoadOptionNone, request, client->CreateRemote(),
  5780. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  5781. if (expect_redirect) {
  5782. client->RunUntilRedirectReceived();
  5783. loader->FollowRedirect({}, {}, {}, new_url);
  5784. client->ClearHasReceivedRedirect();
  5785. }
  5786. if (new_url) {
  5787. client->RunUntilRedirectReceived();
  5788. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  5789. }
  5790. client->RunUntilComplete();
  5791. EXPECT_EQ(net::OK, client->completion_status().error_code);
  5792. EXPECT_EQ(was_cached, client->completion_status().exists_in_cache);
  5793. }
  5794. private:
  5795. base::test::ScopedFeatureList feature_list_;
  5796. net::EmbeddedTestServer test_server_;
  5797. std::unique_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_;
  5798. std::unique_ptr<NetworkContext> network_context_;
  5799. };
  5800. TEST_F(NetworkContextSplitCacheTest, CachedUsingNetworkIsolationKey) {
  5801. GURL url = test_server()->GetURL("/resource");
  5802. url::Origin origin_a = url::Origin::Create(GURL("http://a.test/"));
  5803. net::IsolationInfo info_a =
  5804. net::IsolationInfo::CreateForInternalRequest(origin_a);
  5805. LoadAndVerifyCached(url, info_a, false /* was_cached */);
  5806. // Load again with a different isolation key. The cached entry should not be
  5807. // loaded.
  5808. url::Origin origin_b = url::Origin::Create(GURL("http://b.test/"));
  5809. net::IsolationInfo info_b =
  5810. net::IsolationInfo::CreateForInternalRequest(origin_b);
  5811. LoadAndVerifyCached(url, info_b, false /* was_cached */);
  5812. // Load again with the same isolation key. The cached entry should be loaded.
  5813. LoadAndVerifyCached(url, info_b, true /* was_cached */);
  5814. }
  5815. TEST_F(NetworkContextSplitCacheTest,
  5816. NavigationResourceCachedUsingNetworkIsolationKey) {
  5817. GURL url = test_server()->GetURL("othersite.test", "/main.html");
  5818. url::Origin origin_a = url::Origin::Create(url);
  5819. net::IsolationInfo info_a =
  5820. net::IsolationInfo::Create(net::IsolationInfo::RequestType::kSubFrame,
  5821. origin_a, origin_a, net::SiteForCookies());
  5822. LoadAndVerifyCached(url, info_a, false /* was_cached */);
  5823. // Load again with a different isolation key. The cached entry should not be
  5824. // loaded.
  5825. GURL url_b = test_server()->GetURL("/main.html");
  5826. url::Origin origin_b = url::Origin::Create(url_b);
  5827. net::IsolationInfo info_b =
  5828. net::IsolationInfo::Create(net::IsolationInfo::RequestType::kSubFrame,
  5829. origin_b, origin_b, net::SiteForCookies());
  5830. LoadAndVerifyCached(url_b, info_b, false /* was_cached */);
  5831. // Load again with the same isolation key. The cached entry should be loaded.
  5832. LoadAndVerifyCached(url_b, info_b, true /* was_cached */);
  5833. }
  5834. TEST_F(NetworkContextSplitCacheTest,
  5835. CachedUsingNetworkIsolationKeyWithFrameOrigin) {
  5836. base::test::ScopedFeatureList feature_list;
  5837. feature_list.InitAndEnableFeature(
  5838. net::features::kSplitCacheByNetworkIsolationKey);
  5839. GURL url = test_server()->GetURL("/resource");
  5840. url::Origin origin_a = url::Origin::Create(GURL("http://a.test/"));
  5841. net::IsolationInfo info_a =
  5842. net::IsolationInfo::Create(net::IsolationInfo::RequestType::kOther,
  5843. origin_a, origin_a, net::SiteForCookies());
  5844. LoadAndVerifyCached(url, info_a, false /* was_cached */);
  5845. // Load again with a different isolation key. The cached entry should not be
  5846. // loaded.
  5847. url::Origin origin_b = url::Origin::Create(GURL("http://b.test/"));
  5848. net::IsolationInfo info_b =
  5849. net::IsolationInfo::Create(net::IsolationInfo::RequestType::kOther,
  5850. origin_a, origin_b, net::SiteForCookies());
  5851. LoadAndVerifyCached(url, info_b, false /* was_cached */);
  5852. }
  5853. TEST_F(NetworkContextSplitCacheTest,
  5854. NavigationResourceRedirectNetworkIsolationKey) {
  5855. // Create a request that redirects.
  5856. GURL url = test_server()->GetURL(
  5857. "/server-redirect?" +
  5858. test_server()->GetURL("othersite.test", "/title1.html").spec());
  5859. url::Origin origin = url::Origin::Create(url);
  5860. net::IsolationInfo info = net::IsolationInfo::Create(
  5861. net::IsolationInfo::RequestType::kMainFrame, origin, origin,
  5862. net::SiteForCookies::FromOrigin(origin));
  5863. LoadAndVerifyCached(url, info, false /* was_cached */,
  5864. true /* expect_redirect */);
  5865. // Now directly load with the key using the redirected URL. This should be a
  5866. // cache hit.
  5867. GURL redirected_url = test_server()->GetURL("othersite.test", "/title1.html");
  5868. url::Origin redirected_origin = url::Origin::Create(redirected_url);
  5869. LoadAndVerifyCached(redirected_url, info.CreateForRedirect(redirected_origin),
  5870. true /* was_cached */);
  5871. // A non-navigation resource with the same key and url should also be cached.
  5872. net::IsolationInfo non_navigation_redirected_info =
  5873. net::IsolationInfo::Create(
  5874. net::IsolationInfo::RequestType::kOther, redirected_origin,
  5875. redirected_origin,
  5876. net::SiteForCookies::FromOrigin(redirected_origin));
  5877. LoadAndVerifyCached(redirected_url, non_navigation_redirected_info,
  5878. true /* was_cached */);
  5879. }
  5880. TEST_F(NetworkContextSplitCacheTest, AutomaticallyAssignIsolationInfo) {
  5881. GURL url = test_server()->GetURL("/resource");
  5882. // Load with an automatically assigned IsolationInfo, which should populate
  5883. // the cache using the IsolationInfo for |url|'s origin.
  5884. LoadAndVerifyCached(url, net::IsolationInfo(), false /* was_cached */,
  5885. false /* expect_redirect */, absl::nullopt /* new_url */,
  5886. true /* automatically_assign_isolation_info */);
  5887. // Load again with a different isolation info. The cached entry should not be
  5888. // loaded.
  5889. url::Origin other_origin = url::Origin::Create(GURL("http://other.test/"));
  5890. net::IsolationInfo other_info =
  5891. net::IsolationInfo::CreateForInternalRequest(other_origin);
  5892. LoadAndVerifyCached(url, other_info, false /* was_cached */);
  5893. // Load explicitly using the requested URL's own IsolationInfo, which should
  5894. // use the cached entry.
  5895. url::Origin origin = url::Origin::Create(GURL(url));
  5896. net::IsolationInfo info =
  5897. net::IsolationInfo::CreateForInternalRequest(origin);
  5898. LoadAndVerifyCached(url, info, true /* was_cached */);
  5899. }
  5900. TEST_F(NetworkContextTest, EnableTrustTokens) {
  5901. base::test::ScopedFeatureList scoped_feature_list;
  5902. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  5903. std::unique_ptr<NetworkContext> network_context =
  5904. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5905. EXPECT_TRUE(network_context->trust_token_store());
  5906. base::RunLoop run_loop;
  5907. bool success = false;
  5908. network_context->trust_token_store()->ExecuteOrEnqueue(
  5909. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  5910. success = !!store;
  5911. run_loop.Quit();
  5912. }));
  5913. run_loop.Run();
  5914. EXPECT_TRUE(success);
  5915. }
  5916. TEST_F(NetworkContextTestWithMockTime, EnableTrustTokensWithStoreOnDisk) {
  5917. base::test::ScopedFeatureList scoped_feature_list;
  5918. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  5919. base::ScopedTempDir dir;
  5920. ASSERT_TRUE(dir.CreateUniqueTempDir());
  5921. base::FilePath database_name(FILE_PATH_LITERAL("my_token_store"));
  5922. {
  5923. auto params = CreateNetworkContextParamsForTesting();
  5924. params->file_paths = mojom::NetworkContextFilePaths::New();
  5925. params->file_paths->data_directory = dir.GetPath();
  5926. params->file_paths->trust_token_database_name = database_name;
  5927. std::unique_ptr<NetworkContext> network_context =
  5928. CreateContextWithParams(std::move(params));
  5929. base::RunLoop run_loop;
  5930. network_context->trust_token_store()->ExecuteOrEnqueue(
  5931. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  5932. DCHECK(store);
  5933. store->AddTokens(*SuitableTrustTokenOrigin::Create(
  5934. GURL("https://trusttoken.com/")),
  5935. std::vector<std::string>{"token"}, "issuing key");
  5936. run_loop.Quit();
  5937. }));
  5938. // Allow the store time to initialize asynchronously and execute the
  5939. // operation.
  5940. run_loop.Run();
  5941. // Allow the write time to propagate to disk.
  5942. task_environment_.FastForwardBy(2 * kTrustTokenWriteBufferingWindow);
  5943. }
  5944. // Allow the context's backing store time to be torn down asynchronously.
  5945. task_environment_.RunUntilIdle();
  5946. {
  5947. auto params = CreateNetworkContextParamsForTesting();
  5948. params->file_paths = mojom::NetworkContextFilePaths::New();
  5949. params->file_paths->data_directory = dir.GetPath();
  5950. params->file_paths->trust_token_database_name = database_name;
  5951. std::unique_ptr<NetworkContext> network_context =
  5952. CreateContextWithParams(std::move(params));
  5953. base::RunLoop run_loop;
  5954. absl::optional<int> obtained_num_tokens;
  5955. network_context->trust_token_store()->ExecuteOrEnqueue(
  5956. base::BindLambdaForTesting(
  5957. [&obtained_num_tokens, &run_loop](TrustTokenStore* store) {
  5958. DCHECK(store);
  5959. obtained_num_tokens =
  5960. store->CountTokens(*SuitableTrustTokenOrigin::Create(
  5961. GURL("https://trusttoken.com/")));
  5962. run_loop.Quit();
  5963. }));
  5964. // Allow the store time to initialize asynchronously.
  5965. run_loop.Run();
  5966. EXPECT_THAT(obtained_num_tokens, Optional(1));
  5967. }
  5968. // Allow the context's backing store time to be destroyed asynchronously.
  5969. task_environment_.RunUntilIdle();
  5970. }
  5971. TEST_F(NetworkContextTest, DisableTrustTokens) {
  5972. base::test::ScopedFeatureList scoped_feature_list;
  5973. scoped_feature_list.InitAndDisableFeature(features::kTrustTokens);
  5974. std::unique_ptr<NetworkContext> network_context =
  5975. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  5976. // Allow the store time to initialize asynchronously.
  5977. task_environment_.RunUntilIdle();
  5978. EXPECT_FALSE(network_context->trust_token_store());
  5979. }
  5980. class NetworkContextExpectBadMessageTest : public NetworkContextTest {
  5981. public:
  5982. NetworkContextExpectBadMessageTest() {
  5983. mojo::SetDefaultProcessErrorHandler(
  5984. base::BindLambdaForTesting([&](const std::string&) {
  5985. EXPECT_FALSE(got_bad_message_);
  5986. got_bad_message_ = true;
  5987. }));
  5988. }
  5989. ~NetworkContextExpectBadMessageTest() override {
  5990. mojo::SetDefaultProcessErrorHandler(base::NullCallback());
  5991. }
  5992. protected:
  5993. void AssertBadMessage() { EXPECT_TRUE(got_bad_message_); }
  5994. bool got_bad_message_ = false;
  5995. };
  5996. TEST_F(NetworkContextExpectBadMessageTest,
  5997. FailsTrustTokenBearingRequestWhenTrustTokensIsDisabled) {
  5998. base::test::ScopedFeatureList scoped_feature_list;
  5999. scoped_feature_list.InitAndDisableFeature(features::kTrustTokens);
  6000. std::unique_ptr<NetworkContext> network_context =
  6001. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6002. // Allow the store time to initialize asynchronously.
  6003. task_environment_.RunUntilIdle();
  6004. EXPECT_FALSE(network_context->trust_token_store());
  6005. ResourceRequest my_request;
  6006. my_request.request_initiator =
  6007. url::Origin::Create(GURL("https://initiator.com"));
  6008. my_request.trust_token_params =
  6009. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  6010. std::unique_ptr<TestURLLoaderClient> client =
  6011. FetchRequest(my_request, network_context.get());
  6012. AssertBadMessage();
  6013. }
  6014. TEST_F(NetworkContextExpectBadMessageTest,
  6015. FailsTrustTokenRedemptionWhenForbidden) {
  6016. base::test::ScopedFeatureList scoped_feature_list;
  6017. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6018. std::unique_ptr<NetworkContext> network_context =
  6019. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6020. // Allow |network_context|'s Trust Tokens store time to initialize
  6021. // asynchronously, if necessary.
  6022. task_environment_.RunUntilIdle();
  6023. ASSERT_TRUE(network_context->trust_token_store());
  6024. ResourceRequest my_request;
  6025. my_request.trust_token_params =
  6026. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  6027. my_request.trust_token_params->type =
  6028. mojom::TrustTokenOperationType::kRedemption;
  6029. auto factory_params = mojom::URLLoaderFactoryParams::New();
  6030. factory_params->trust_token_redemption_policy =
  6031. mojom::TrustTokenRedemptionPolicy::kForbid;
  6032. std::unique_ptr<TestURLLoaderClient> client =
  6033. FetchRequest(my_request, network_context.get(), mojom::kURLLoadOptionNone,
  6034. mojom::kBrowserProcessId, std::move(factory_params));
  6035. AssertBadMessage();
  6036. }
  6037. TEST_F(NetworkContextExpectBadMessageTest,
  6038. FailsTrustTokenSigningWhenForbidden) {
  6039. base::test::ScopedFeatureList scoped_feature_list;
  6040. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6041. std::unique_ptr<NetworkContext> network_context =
  6042. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6043. // Allow |network_context|'s Trust Tokens store time to initialize
  6044. // asynchronously, if necessary.
  6045. task_environment_.RunUntilIdle();
  6046. ASSERT_TRUE(network_context->trust_token_store());
  6047. ResourceRequest my_request;
  6048. my_request.trust_token_params =
  6049. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  6050. my_request.trust_token_params->type =
  6051. mojom::TrustTokenOperationType::kSigning;
  6052. auto factory_params = mojom::URLLoaderFactoryParams::New();
  6053. factory_params->trust_token_redemption_policy =
  6054. mojom::TrustTokenRedemptionPolicy::kForbid;
  6055. std::unique_ptr<TestURLLoaderClient> client =
  6056. FetchRequest(my_request, network_context.get(), mojom::kURLLoadOptionNone,
  6057. mojom::kBrowserProcessId, std::move(factory_params));
  6058. AssertBadMessage();
  6059. }
  6060. TEST_F(NetworkContextTest,
  6061. AttemptsTrustTokenBearingRequestWhenTrustTokensIsEnabled) {
  6062. base::test::ScopedFeatureList scoped_feature_list;
  6063. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6064. std::unique_ptr<NetworkContext> network_context =
  6065. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6066. // Allow the store time to initialize asynchronously.
  6067. task_environment_.RunUntilIdle();
  6068. ResourceRequest my_request;
  6069. my_request.trust_token_params =
  6070. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  6071. // Since the request doesn't have a destination URL suitable for use as a
  6072. // Trust Tokens issuer, it should fail.
  6073. std::unique_ptr<TestURLLoaderClient> client = FetchRequest(
  6074. my_request, network_context.get(), mojom::kURLLoadOptionNone,
  6075. mojom::kBrowserProcessId, mojom::URLLoaderFactoryParams::New());
  6076. EXPECT_EQ(client->completion_status().error_code,
  6077. net::ERR_TRUST_TOKEN_OPERATION_FAILED);
  6078. EXPECT_EQ(client->completion_status().trust_token_operation_status,
  6079. mojom::TrustTokenOperationStatus::kInvalidArgument);
  6080. }
  6081. TEST_F(NetworkContextTest,
  6082. RejectsTrustTokenBearingRequestWhenThirdPartyCookiesAreDisabled) {
  6083. base::test::ScopedFeatureList scoped_feature_list;
  6084. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6085. std::unique_ptr<NetworkContext> network_context =
  6086. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6087. // Allow the store time to initialize asynchronously.
  6088. base::RunLoop run_loop;
  6089. network_context->trust_token_store()->ExecuteOrEnqueue(
  6090. base::BindLambdaForTesting(
  6091. [&run_loop](TrustTokenStore* unused) { run_loop.Quit(); }));
  6092. run_loop.Run();
  6093. network_context->cookie_manager()->BlockThirdPartyCookies(true);
  6094. ResourceRequest my_request;
  6095. my_request.trust_token_params =
  6096. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  6097. std::unique_ptr<TestURLLoaderClient> client = FetchRequest(
  6098. my_request, network_context.get(), mojom::kURLLoadOptionNone,
  6099. mojom::kBrowserProcessId, mojom::URLLoaderFactoryParams::New());
  6100. EXPECT_EQ(client->completion_status().error_code,
  6101. net::ERR_TRUST_TOKEN_OPERATION_FAILED);
  6102. EXPECT_EQ(client->completion_status().trust_token_operation_status,
  6103. mojom::TrustTokenOperationStatus::kUnavailable);
  6104. }
  6105. TEST_F(NetworkContextTest, NoAvailableTrustTokensWhenTrustTokensAreDisabled) {
  6106. base::test::ScopedFeatureList scoped_feature_list;
  6107. scoped_feature_list.InitAndDisableFeature(features::kTrustTokens);
  6108. std::unique_ptr<NetworkContext> network_context =
  6109. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6110. // Allow the store time to initialize asynchronously.
  6111. base::RunLoop run_loop;
  6112. absl::optional<std::vector<mojom::StoredTrustTokensForIssuerPtr>>
  6113. trust_tokens;
  6114. network_context->GetStoredTrustTokenCounts(base::BindLambdaForTesting(
  6115. [&trust_tokens,
  6116. &run_loop](std::vector<mojom::StoredTrustTokensForIssuerPtr> tokens) {
  6117. trust_tokens = std::move(tokens);
  6118. run_loop.Quit();
  6119. }));
  6120. run_loop.Run();
  6121. ASSERT_TRUE(trust_tokens.has_value());
  6122. EXPECT_TRUE(trust_tokens->empty());
  6123. }
  6124. TEST_F(NetworkContextTest, GetStoredTrustTokens) {
  6125. base::test::ScopedFeatureList scoped_feature_list;
  6126. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6127. std::unique_ptr<NetworkContext> network_context =
  6128. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6129. base::RunLoop run_loop;
  6130. // Query Trust Tokens before adding the mock token.
  6131. absl::optional<std::vector<mojom::StoredTrustTokensForIssuerPtr>>
  6132. trust_tokens_before_adding;
  6133. network_context->GetStoredTrustTokenCounts(base::BindLambdaForTesting(
  6134. [&](std::vector<mojom::StoredTrustTokensForIssuerPtr> tokens) {
  6135. trust_tokens_before_adding = std::move(tokens);
  6136. }));
  6137. // Add a mock token.
  6138. network_context->trust_token_store()->ExecuteOrEnqueue(
  6139. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  6140. DCHECK(store);
  6141. store->AddTokens(
  6142. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken.com")),
  6143. std::vector<std::string>{"token"}, "issuing key");
  6144. }));
  6145. // Query Trust Tokens after adding the mock token.
  6146. absl::optional<std::vector<mojom::StoredTrustTokensForIssuerPtr>>
  6147. trust_tokens_after_adding;
  6148. network_context->GetStoredTrustTokenCounts(base::BindLambdaForTesting(
  6149. [&](std::vector<mojom::StoredTrustTokensForIssuerPtr> tokens) {
  6150. trust_tokens_after_adding = std::move(tokens);
  6151. run_loop.Quit();
  6152. }));
  6153. // Allow the store time to initialize asynchronously and execute the
  6154. // operations.
  6155. run_loop.Run();
  6156. ASSERT_TRUE(trust_tokens_before_adding.has_value());
  6157. EXPECT_EQ(trust_tokens_before_adding->size(), 0ul);
  6158. ASSERT_TRUE(trust_tokens_after_adding.has_value());
  6159. ASSERT_EQ(trust_tokens_after_adding->size(), 1ul);
  6160. EXPECT_EQ(trust_tokens_after_adding.value()[0]->issuer.Serialize(),
  6161. "https://trusttoken.com");
  6162. }
  6163. TEST_F(NetworkContextTest, GetStoredTrustTokensReentrant) {
  6164. base::test::ScopedFeatureList scoped_feature_list;
  6165. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6166. std::unique_ptr<NetworkContext> network_context =
  6167. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6168. // Add a mock token.
  6169. base::RunLoop run_loop;
  6170. network_context->trust_token_store()->ExecuteOrEnqueue(
  6171. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  6172. DCHECK(store);
  6173. store->AddTokens(
  6174. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken.com")),
  6175. std::vector<std::string>{"token"}, "issuing key");
  6176. }));
  6177. absl::optional<std::vector<mojom::StoredTrustTokensForIssuerPtr>>
  6178. trust_tokens;
  6179. absl::optional<std::vector<mojom::StoredTrustTokensForIssuerPtr>>
  6180. reentrant_trust_tokens;
  6181. network_context->GetStoredTrustTokenCounts(base::BindLambdaForTesting(
  6182. [&](std::vector<mojom::StoredTrustTokensForIssuerPtr> tokens) {
  6183. network_context->GetStoredTrustTokenCounts(base::BindLambdaForTesting(
  6184. [&](std::vector<mojom::StoredTrustTokensForIssuerPtr> tokens) {
  6185. reentrant_trust_tokens = std::move(tokens);
  6186. run_loop.Quit();
  6187. }));
  6188. trust_tokens = std::move(tokens);
  6189. }));
  6190. // Allow the store time to initialize asynchronously and execute the
  6191. // operations.
  6192. run_loop.Run();
  6193. ASSERT_TRUE(trust_tokens.has_value());
  6194. ASSERT_TRUE(reentrant_trust_tokens.has_value());
  6195. EXPECT_EQ(trust_tokens->size(), reentrant_trust_tokens->size());
  6196. EXPECT_EQ(trust_tokens.value()[0]->issuer,
  6197. reentrant_trust_tokens.value()[0]->issuer);
  6198. EXPECT_EQ(trust_tokens.value()[0]->count,
  6199. reentrant_trust_tokens.value()[0]->count);
  6200. }
  6201. TEST_F(NetworkContextTest,
  6202. DeleteStoredTrustTokensReportsErrorWhenFeatureIsDisabled) {
  6203. base::test::ScopedFeatureList scoped_feature_list;
  6204. scoped_feature_list.InitAndDisableFeature(features::kTrustTokens);
  6205. std::unique_ptr<NetworkContext> network_context =
  6206. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6207. // Allow the store time to initialize asynchronously.
  6208. base::RunLoop run_loop;
  6209. absl::optional<mojom::DeleteStoredTrustTokensStatus> actual_status;
  6210. network_context->DeleteStoredTrustTokens(
  6211. url::Origin::Create(GURL("https://example.com")),
  6212. base::BindLambdaForTesting(
  6213. [&](mojom::DeleteStoredTrustTokensStatus status) {
  6214. actual_status = status;
  6215. run_loop.Quit();
  6216. }));
  6217. run_loop.Run();
  6218. EXPECT_THAT(
  6219. actual_status,
  6220. Optional(mojom::DeleteStoredTrustTokensStatus::kFailureFeatureDisabled));
  6221. }
  6222. TEST_F(NetworkContextTest,
  6223. DeleteStoredTrustTokensReportsErrorWithInvalidOrigin) {
  6224. base::test::ScopedFeatureList scoped_feature_list;
  6225. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6226. std::unique_ptr<NetworkContext> network_context =
  6227. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6228. // Allow the store time to initialize asynchronously.
  6229. base::RunLoop run_loop;
  6230. absl::optional<mojom::DeleteStoredTrustTokensStatus> actual_status;
  6231. network_context->DeleteStoredTrustTokens(
  6232. url::Origin::Create(GURL("ws://example.com")),
  6233. base::BindLambdaForTesting(
  6234. [&](mojom::DeleteStoredTrustTokensStatus status) {
  6235. actual_status = status;
  6236. run_loop.Quit();
  6237. }));
  6238. run_loop.Run();
  6239. EXPECT_THAT(
  6240. actual_status,
  6241. Optional(mojom::DeleteStoredTrustTokensStatus::kFailureInvalidOrigin));
  6242. }
  6243. TEST_F(NetworkContextTest, DeleteStoredTrustTokens) {
  6244. base::test::ScopedFeatureList scoped_feature_list;
  6245. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6246. std::unique_ptr<NetworkContext> network_context =
  6247. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6248. base::RunLoop run_loop;
  6249. const SuitableTrustTokenOrigin issuer_origin_to_delete =
  6250. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken-delete.com"));
  6251. const SuitableTrustTokenOrigin issuer_origin_to_keep =
  6252. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken-keep.com"));
  6253. // Add two mock tokens from different issuers.
  6254. network_context->trust_token_store()->ExecuteOrEnqueue(
  6255. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  6256. DCHECK(store);
  6257. store->AddTokens(issuer_origin_to_delete,
  6258. std::vector<std::string>{"token"}, "issuing key");
  6259. store->AddTokens(issuer_origin_to_keep,
  6260. std::vector<std::string>{"token"}, "issuing key");
  6261. ASSERT_EQ(store->GetStoredTrustTokenCounts().size(), 2ul);
  6262. }));
  6263. // Delete all Trust Tokens for one of the issuers.
  6264. absl::optional<mojom::DeleteStoredTrustTokensStatus> delete_status;
  6265. network_context->DeleteStoredTrustTokens(
  6266. issuer_origin_to_delete.origin(),
  6267. base::BindLambdaForTesting(
  6268. [&](mojom::DeleteStoredTrustTokensStatus status) {
  6269. delete_status = status;
  6270. }));
  6271. // Query Trust Tokens after deleting one of the mock token.
  6272. absl::optional<base::flat_map<SuitableTrustTokenOrigin, int>> trust_tokens;
  6273. network_context->trust_token_store()->ExecuteOrEnqueue(
  6274. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  6275. trust_tokens = store->GetStoredTrustTokenCounts();
  6276. run_loop.Quit();
  6277. }));
  6278. // Allow the store time to initialize asynchronously and execute the
  6279. // operations.
  6280. run_loop.Run();
  6281. EXPECT_THAT(
  6282. delete_status,
  6283. Optional(mojom::DeleteStoredTrustTokensStatus::kSuccessTokensDeleted));
  6284. ASSERT_TRUE(trust_tokens->contains(issuer_origin_to_keep));
  6285. EXPECT_EQ(trust_tokens->at(issuer_origin_to_keep), 1);
  6286. }
  6287. TEST_F(NetworkContextTest, DeleteStoredTrustTokensReentrant) {
  6288. base::test::ScopedFeatureList scoped_feature_list;
  6289. scoped_feature_list.InitAndEnableFeature(features::kTrustTokens);
  6290. std::unique_ptr<NetworkContext> network_context =
  6291. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6292. base::RunLoop run_loop;
  6293. const SuitableTrustTokenOrigin issuer_origin_foo =
  6294. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken-foo.com"));
  6295. const SuitableTrustTokenOrigin issuer_origin_bar =
  6296. *SuitableTrustTokenOrigin::Create(GURL("https://trusttoken-bar.com"));
  6297. // Add two mock tokens from different issuers.
  6298. network_context->trust_token_store()->ExecuteOrEnqueue(
  6299. base::BindLambdaForTesting([&](TrustTokenStore* store) {
  6300. DCHECK(store);
  6301. store->AddTokens(issuer_origin_foo, std::vector<std::string>{"token"},
  6302. "issuing key");
  6303. store->AddTokens(issuer_origin_bar, std::vector<std::string>{"token"},
  6304. "issuing key");
  6305. ASSERT_EQ(store->GetStoredTrustTokenCounts().size(), 2ul);
  6306. }));
  6307. // Delete all Trust Tokens for both issuers simultaneously.
  6308. absl::optional<mojom::DeleteStoredTrustTokensStatus> delete_status_foo;
  6309. absl::optional<mojom::DeleteStoredTrustTokensStatus> delete_status_bar;
  6310. network_context->DeleteStoredTrustTokens(
  6311. issuer_origin_foo.origin(),
  6312. base::BindLambdaForTesting(
  6313. [&](mojom::DeleteStoredTrustTokensStatus status) {
  6314. delete_status_foo = status;
  6315. network_context->DeleteStoredTrustTokens(
  6316. issuer_origin_bar,
  6317. base::BindLambdaForTesting(
  6318. [&](mojom::DeleteStoredTrustTokensStatus status) {
  6319. delete_status_bar = status;
  6320. run_loop.Quit();
  6321. }));
  6322. }));
  6323. // Allow the store time to initialize asynchronously and execute the
  6324. // operations.
  6325. run_loop.Run();
  6326. EXPECT_THAT(
  6327. delete_status_foo,
  6328. Optional(mojom::DeleteStoredTrustTokensStatus::kSuccessTokensDeleted));
  6329. EXPECT_THAT(
  6330. delete_status_bar,
  6331. Optional(mojom::DeleteStoredTrustTokensStatus::kSuccessTokensDeleted));
  6332. }
  6333. TEST_F(NetworkContextTest, HttpAuthUrlFilter) {
  6334. std::unique_ptr<NetworkContext> network_context =
  6335. CreateContextWithParams(CreateNetworkContextParamsForTesting());
  6336. const GURL kGoogle("https://www.google.com");
  6337. const GURL kGoogleSubdomain("https://subdomain.google.com");
  6338. const GURL kBlocked("https://www.blocked.com");
  6339. auto is_url_allowed_to_use_auth_schemes =
  6340. [&network_context](const GURL& url) {
  6341. return network_context->GetHttpAuthPreferences()
  6342. ->IsAllowedToUseAllHttpAuthSchemes(url::SchemeHostPort(url));
  6343. };
  6344. network::mojom::HttpAuthDynamicParamsPtr auth_dynamic_params =
  6345. network::mojom::HttpAuthDynamicParams::New();
  6346. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6347. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6348. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kBlocked));
  6349. auth_dynamic_params->patterns_allowed_to_use_all_schemes =
  6350. std::vector<std::string>{"subdomain.google.com"};
  6351. network_context->OnHttpAuthDynamicParamsChanged(auth_dynamic_params.get());
  6352. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6353. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6354. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(
  6355. GURL("https://subdomain.blocked.com")));
  6356. auth_dynamic_params->patterns_allowed_to_use_all_schemes =
  6357. std::vector<std::string>{};
  6358. network_context->OnHttpAuthDynamicParamsChanged(auth_dynamic_params.get());
  6359. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6360. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6361. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kBlocked));
  6362. auth_dynamic_params->patterns_allowed_to_use_all_schemes =
  6363. std::vector<std::string>{"google.com"};
  6364. network_context->OnHttpAuthDynamicParamsChanged(auth_dynamic_params.get());
  6365. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6366. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6367. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kBlocked));
  6368. auth_dynamic_params->patterns_allowed_to_use_all_schemes =
  6369. std::vector<std::string>{"https://google.com/path"};
  6370. network_context->OnHttpAuthDynamicParamsChanged(auth_dynamic_params.get());
  6371. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6372. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6373. EXPECT_FALSE(is_url_allowed_to_use_auth_schemes(kBlocked));
  6374. auth_dynamic_params->patterns_allowed_to_use_all_schemes =
  6375. std::vector<std::string>{"*"};
  6376. network_context->OnHttpAuthDynamicParamsChanged(auth_dynamic_params.get());
  6377. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogle));
  6378. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kGoogleSubdomain));
  6379. EXPECT_TRUE(is_url_allowed_to_use_auth_schemes(kBlocked));
  6380. }
  6381. } // namespace
  6382. } // namespace network