url_loader_unittest.cc 299 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409
  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 <stdint.h>
  5. #include <limits>
  6. #include <list>
  7. #include <memory>
  8. #include <string>
  9. #include <utility>
  10. #include <vector>
  11. #include "base/auto_reset.h"
  12. #include "base/bind.h"
  13. #include "base/callback_helpers.h"
  14. #include "base/files/file.h"
  15. #include "base/files/file_path.h"
  16. #include "base/files/file_util.h"
  17. #include "base/memory/raw_ptr.h"
  18. #include "base/memory/ref_counted.h"
  19. #include "base/memory/weak_ptr.h"
  20. #include "base/metrics/statistics_recorder.h"
  21. #include "base/no_destructor.h"
  22. #include "base/path_service.h"
  23. #include "base/run_loop.h"
  24. #include "base/strings/escape.h"
  25. #include "base/strings/strcat.h"
  26. #include "base/strings/stringprintf.h"
  27. #include "base/strings/utf_string_conversions.h"
  28. #include "base/test/bind.h"
  29. #include "base/test/gtest_util.h"
  30. #include "base/test/metrics/histogram_tester.h"
  31. #include "base/test/scoped_feature_list.h"
  32. #include "base/test/task_environment.h"
  33. #include "base/threading/thread_task_runner_handle.h"
  34. #include "base/time/time.h"
  35. #include "build/build_config.h"
  36. #include "mojo/public/c/system/data_pipe.h"
  37. #include "mojo/public/cpp/bindings/pending_remote.h"
  38. #include "mojo/public/cpp/bindings/remote.h"
  39. #include "mojo/public/cpp/bindings/self_owned_receiver.h"
  40. #include "mojo/public/cpp/system/data_pipe_utils.h"
  41. #include "mojo/public/cpp/system/wait.h"
  42. #include "net/base/completion_repeating_callback.h"
  43. #include "net/base/features.h"
  44. #include "net/base/io_buffer.h"
  45. #include "net/base/ip_endpoint.h"
  46. #include "net/base/isolation_info.h"
  47. #include "net/base/load_flags.h"
  48. #include "net/base/mime_sniffer.h"
  49. #include "net/base/net_errors.h"
  50. #include "net/base/transport_info.h"
  51. #include "net/cert/pki/parse_name.h"
  52. #include "net/cert/test_root_certs.h"
  53. #include "net/cookies/cookie_access_result.h"
  54. #include "net/cookies/cookie_change_dispatcher.h"
  55. #include "net/cookies/cookie_inclusion_status.h"
  56. #include "net/cookies/cookie_util.h"
  57. #include "net/dns/mock_host_resolver.h"
  58. #include "net/http/http_network_session.h"
  59. #include "net/http/http_response_info.h"
  60. #include "net/http/http_transaction_test_util.h"
  61. #include "net/log/net_log_event_type.h"
  62. #include "net/log/test_net_log.h"
  63. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  64. #include "net/socket/socket_test_util.h"
  65. #include "net/ssl/client_cert_identity_test_util.h"
  66. #include "net/test/cert_test_util.h"
  67. #include "net/test/embedded_test_server/controllable_http_response.h"
  68. #include "net/test/embedded_test_server/embedded_test_server.h"
  69. #include "net/test/embedded_test_server/http_response.h"
  70. #include "net/test/gtest_util.h"
  71. #include "net/test/quic_simple_test_server.h"
  72. #include "net/test/test_data_directory.h"
  73. #include "net/test/url_request/url_request_failed_job.h"
  74. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  75. #include "net/url_request/url_request.h"
  76. #include "net/url_request/url_request_context.h"
  77. #include "net/url_request/url_request_context_builder.h"
  78. #include "net/url_request/url_request_filter.h"
  79. #include "net/url_request/url_request_interceptor.h"
  80. #include "net/url_request/url_request_job.h"
  81. #include "net/url_request/url_request_test_job.h"
  82. #include "net/url_request/url_request_test_util.h"
  83. #include "services/network/public/cpp/cors/origin_access_list.h"
  84. #include "services/network/public/cpp/features.h"
  85. #include "services/network/public/cpp/ip_address_space_util.h"
  86. #include "services/network/public/cpp/resource_request.h"
  87. #include "services/network/public/mojom/cookie_access_observer.mojom-forward.h"
  88. #include "services/network/public/mojom/cookie_access_observer.mojom.h"
  89. #include "services/network/public/mojom/early_hints.mojom.h"
  90. #include "services/network/public/mojom/ip_address_space.mojom-shared.h"
  91. #include "services/network/public/mojom/ip_address_space.mojom.h"
  92. #include "services/network/public/mojom/network_context.mojom.h"
  93. #include "services/network/public/mojom/network_service.mojom.h"
  94. #include "services/network/public/mojom/trust_tokens.mojom-shared.h"
  95. #include "services/network/public/mojom/url_loader.mojom.h"
  96. #include "services/network/resource_scheduler/resource_scheduler_client.h"
  97. #include "services/network/test/mock_devtools_observer.h"
  98. #include "services/network/test/test_data_pipe_getter.h"
  99. #include "services/network/test/test_network_context_client.h"
  100. #include "services/network/test/test_url_loader_client.h"
  101. #include "services/network/test/test_url_loader_network_observer.h"
  102. #include "services/network/test/url_loader_context_for_tests.h"
  103. #include "services/network/test_chunked_data_pipe_getter.h"
  104. #include "services/network/trust_tokens/trust_token_key_commitment_getter.h"
  105. #include "services/network/trust_tokens/trust_token_request_helper.h"
  106. #include "services/network/trust_tokens/trust_token_request_helper_factory.h"
  107. #include "services/network/url_loader.h"
  108. #include "services/network/url_request_context_owner.h"
  109. #include "testing/gmock/include/gmock/gmock.h"
  110. #include "testing/gtest/include/gtest/gtest.h"
  111. #include "third_party/abseil-cpp/absl/types/optional.h"
  112. #include "url/gurl.h"
  113. #if BUILDFLAG(IS_ANDROID)
  114. #include "base/android/radio_utils.h"
  115. #include "net/android/radio_activity_tracker.h"
  116. #include "services/network/radio_monitor_android.h"
  117. #endif
  118. namespace network {
  119. namespace {
  120. using ::net::test::IsError;
  121. using ::net::test::IsOk;
  122. using ::testing::ElementsAre;
  123. using ::testing::Eq;
  124. using ::testing::Optional;
  125. using ::testing::Pointee;
  126. using ::testing::SizeIs;
  127. using ::testing::ValuesIn;
  128. // Returns a URLLoader::DeleteCallback that destroys |url_loader| and quits
  129. // |run_loop| when invoked. Tests must wait on the RunLoop to ensure nothing is
  130. // leaked. Takes a std::unique_ptr<URLLoader>* instead of a unique_ptr because
  131. // the callback must be created before the URLLoader is actually created.
  132. URLLoader::DeleteCallback DeleteLoaderCallback(
  133. base::RunLoop* run_loop,
  134. std::unique_ptr<URLLoader>* url_loader) {
  135. return base::BindOnce(
  136. [](base::RunLoop* run_loop, std::unique_ptr<URLLoader>* url_loader,
  137. URLLoader* url_loader_ptr) {
  138. DCHECK_EQ(url_loader->get(), url_loader_ptr);
  139. url_loader->reset();
  140. run_loop->Quit();
  141. },
  142. run_loop, url_loader);
  143. }
  144. // Returns a URLLoader::DeleteCallback that does nothing, but calls NOTREACHED.
  145. // Tests that use a URLLoader that actually tries to delete itself shouldn't use
  146. // this method, as URLLoaders don't expect to be alive after they invoke their
  147. // delete callback.
  148. URLLoader::DeleteCallback NeverInvokedDeleteLoaderCallback() {
  149. return base::BindOnce([](URLLoader* /* loader*/) { NOTREACHED(); });
  150. }
  151. constexpr char kBodyReadFromNetBeforePausedHistogram[] =
  152. "Network.URLLoader.BodyReadFromNetBeforePaused";
  153. constexpr char kTestAuthURL[] = "/auth-basic?password=PASS&realm=REALM";
  154. constexpr char kInsecureHost[] = "othersite.test";
  155. constexpr char kHostnameWithAliases[] = "www.example.test";
  156. constexpr char kHostnameWithoutAliases[] = "www.other.test";
  157. static ResourceRequest CreateResourceRequest(const char* method,
  158. const GURL& url) {
  159. ResourceRequest request;
  160. request.method = std::string(method);
  161. request.url = url;
  162. request.site_for_cookies =
  163. net::SiteForCookies::FromUrl(url); // bypass third-party cookie blocking
  164. url::Origin origin = url::Origin::Create(url);
  165. request.request_initiator = origin; // ensure initiator is set
  166. request.is_outermost_main_frame = true;
  167. request.trusted_params = network::ResourceRequest::TrustedParams();
  168. request.trusted_params->isolation_info =
  169. net::IsolationInfo::CreateForInternalRequest(origin);
  170. return request;
  171. }
  172. class URLRequestMultipleWritesJob : public net::URLRequestJob {
  173. public:
  174. URLRequestMultipleWritesJob(net::URLRequest* request,
  175. std::list<std::string> packets,
  176. net::Error net_error,
  177. bool async_reads)
  178. : URLRequestJob(request),
  179. packets_(std::move(packets)),
  180. net_error_(net_error),
  181. async_reads_(async_reads) {}
  182. URLRequestMultipleWritesJob(const URLRequestMultipleWritesJob&) = delete;
  183. URLRequestMultipleWritesJob& operator=(const URLRequestMultipleWritesJob&) =
  184. delete;
  185. ~URLRequestMultipleWritesJob() override = default;
  186. // net::URLRequestJob implementation:
  187. void Start() override {
  188. base::ThreadTaskRunnerHandle::Get()->PostTask(
  189. FROM_HERE, base::BindOnce(&URLRequestMultipleWritesJob::StartAsync,
  190. weak_factory_.GetWeakPtr()));
  191. }
  192. int ReadRawData(net::IOBuffer* buf, int buf_size) override {
  193. int result;
  194. if (packets_.empty()) {
  195. result = net_error_;
  196. } else {
  197. std::string packet = packets_.front();
  198. packets_.pop_front();
  199. CHECK_GE(buf_size, static_cast<int>(packet.length()));
  200. memcpy(buf->data(), packet.c_str(), packet.length());
  201. result = packet.length();
  202. }
  203. if (async_reads_) {
  204. base::ThreadTaskRunnerHandle::Get()->PostTask(
  205. FROM_HERE,
  206. base::BindOnce(&URLRequestMultipleWritesJob::ReadRawDataComplete,
  207. weak_factory_.GetWeakPtr(), result));
  208. return net::ERR_IO_PENDING;
  209. }
  210. return result;
  211. }
  212. private:
  213. void StartAsync() { NotifyHeadersComplete(); }
  214. std::list<std::string> packets_;
  215. net::Error net_error_;
  216. bool async_reads_;
  217. base::WeakPtrFactory<URLRequestMultipleWritesJob> weak_factory_{this};
  218. };
  219. class MultipleWritesInterceptor : public net::URLRequestInterceptor {
  220. public:
  221. MultipleWritesInterceptor(std::list<std::string> packets,
  222. net::Error net_error,
  223. bool async_reads)
  224. : packets_(std::move(packets)),
  225. net_error_(net_error),
  226. async_reads_(async_reads) {}
  227. MultipleWritesInterceptor(const MultipleWritesInterceptor&) = delete;
  228. MultipleWritesInterceptor& operator=(const MultipleWritesInterceptor&) =
  229. delete;
  230. ~MultipleWritesInterceptor() override {}
  231. static GURL GetURL() { return GURL("http://foo"); }
  232. // URLRequestInterceptor implementation:
  233. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  234. net::URLRequest* request) const override {
  235. return std::make_unique<URLRequestMultipleWritesJob>(
  236. request, std::move(packets_), net_error_, async_reads_);
  237. }
  238. private:
  239. std::list<std::string> packets_;
  240. net::Error net_error_;
  241. bool async_reads_;
  242. };
  243. // Every read completes synchronously.
  244. class URLRequestEternalSyncReadsJob : public net::URLRequestJob {
  245. public:
  246. // If |fill_entire_buffer| is true, each read fills the entire read buffer at
  247. // once. Otherwise, one byte is read at a time.
  248. URLRequestEternalSyncReadsJob(net::URLRequest* request,
  249. bool fill_entire_buffer)
  250. : URLRequestJob(request), fill_entire_buffer_(fill_entire_buffer) {}
  251. URLRequestEternalSyncReadsJob(const URLRequestEternalSyncReadsJob&) = delete;
  252. URLRequestEternalSyncReadsJob& operator=(
  253. const URLRequestEternalSyncReadsJob&) = delete;
  254. ~URLRequestEternalSyncReadsJob() override = default;
  255. // net::URLRequestJob implementation:
  256. void Start() override {
  257. base::ThreadTaskRunnerHandle::Get()->PostTask(
  258. FROM_HERE, base::BindOnce(&URLRequestEternalSyncReadsJob::StartAsync,
  259. weak_factory_.GetWeakPtr()));
  260. }
  261. int ReadRawData(net::IOBuffer* buf, int buf_size) override {
  262. DCHECK_GT(buf_size, 0);
  263. if (fill_entire_buffer_) {
  264. memset(buf->data(), 'a', buf_size);
  265. return buf_size;
  266. }
  267. buf->data()[0] = 'a';
  268. return 1;
  269. }
  270. private:
  271. void StartAsync() { NotifyHeadersComplete(); }
  272. const bool fill_entire_buffer_;
  273. base::WeakPtrFactory<URLRequestEternalSyncReadsJob> weak_factory_{this};
  274. };
  275. class EternalSyncReadsInterceptor : public net::URLRequestInterceptor {
  276. public:
  277. EternalSyncReadsInterceptor() {}
  278. EternalSyncReadsInterceptor(const EternalSyncReadsInterceptor&) = delete;
  279. EternalSyncReadsInterceptor& operator=(const EternalSyncReadsInterceptor&) =
  280. delete;
  281. ~EternalSyncReadsInterceptor() override {}
  282. static std::string GetHostName() { return "eternal"; }
  283. static GURL GetSingleByteURL() { return GURL("http://eternal/single-byte"); }
  284. static GURL GetFillBufferURL() { return GURL("http://eternal/fill-buffer"); }
  285. // URLRequestInterceptor implementation:
  286. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  287. net::URLRequest* request) const override {
  288. if (request->url() == GetSingleByteURL()) {
  289. return std::make_unique<URLRequestEternalSyncReadsJob>(
  290. request, false /* fill_entire_buffer */);
  291. }
  292. if (request->url() == GetFillBufferURL()) {
  293. return std::make_unique<URLRequestEternalSyncReadsJob>(
  294. request, true /* fill_entire_buffer */);
  295. }
  296. return nullptr;
  297. }
  298. };
  299. // Simulates handing over things to the disk to write before returning to the
  300. // caller.
  301. class URLRequestSimulatedCacheJob : public net::URLRequestJob {
  302. public:
  303. // If |fill_entire_buffer| is true, each read fills the entire read buffer at
  304. // once. Otherwise, one byte is read at a time.
  305. URLRequestSimulatedCacheJob(
  306. net::URLRequest* request,
  307. scoped_refptr<net::IOBuffer>* simulated_cache_dest,
  308. bool use_text_plain)
  309. : URLRequestJob(request),
  310. simulated_cache_dest_(simulated_cache_dest),
  311. use_text_plain_(use_text_plain) {}
  312. URLRequestSimulatedCacheJob(const URLRequestSimulatedCacheJob&) = delete;
  313. URLRequestSimulatedCacheJob& operator=(const URLRequestSimulatedCacheJob&) =
  314. delete;
  315. ~URLRequestSimulatedCacheJob() override = default;
  316. // net::URLRequestJob implementation:
  317. void Start() override {
  318. base::ThreadTaskRunnerHandle::Get()->PostTask(
  319. FROM_HERE, base::BindOnce(&URLRequestSimulatedCacheJob::StartAsync,
  320. weak_factory_.GetWeakPtr()));
  321. }
  322. void GetResponseInfo(net::HttpResponseInfo* info) override {
  323. if (!use_text_plain_)
  324. return URLRequestJob::GetResponseInfo(info);
  325. if (!info->headers) {
  326. info->headers = net::HttpResponseHeaders::TryToCreate(
  327. "HTTP/1.1 200 OK\r\nContent-Type: text/plain");
  328. }
  329. }
  330. int ReadRawData(net::IOBuffer* buf, int buf_size) override {
  331. DCHECK_GT(buf_size, 0);
  332. // Pretend this is the entire network stack, which has sent the buffer
  333. // to some worker thread to be written to disk.
  334. memset(buf->data(), 'a', buf_size);
  335. *simulated_cache_dest_ = buf;
  336. // The network stack will not report the read result until the write
  337. // completes.
  338. return net::ERR_IO_PENDING;
  339. }
  340. private:
  341. void StartAsync() { NotifyHeadersComplete(); }
  342. raw_ptr<scoped_refptr<net::IOBuffer>> simulated_cache_dest_;
  343. bool use_text_plain_;
  344. base::WeakPtrFactory<URLRequestSimulatedCacheJob> weak_factory_{this};
  345. };
  346. class SimulatedCacheInterceptor : public net::URLRequestInterceptor {
  347. public:
  348. explicit SimulatedCacheInterceptor(
  349. scoped_refptr<net::IOBuffer>* simulated_cache_dest,
  350. bool use_text_plain)
  351. : simulated_cache_dest_(simulated_cache_dest),
  352. use_text_plain_(use_text_plain) {}
  353. SimulatedCacheInterceptor(const SimulatedCacheInterceptor&) = delete;
  354. SimulatedCacheInterceptor& operator=(const SimulatedCacheInterceptor&) =
  355. delete;
  356. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  357. net::URLRequest* request) const override {
  358. return std::make_unique<URLRequestSimulatedCacheJob>(
  359. request, simulated_cache_dest_, use_text_plain_);
  360. }
  361. private:
  362. raw_ptr<scoped_refptr<net::IOBuffer>> simulated_cache_dest_;
  363. bool use_text_plain_;
  364. };
  365. // Observes net error results. Thread-compatible.
  366. class ResultObserver {
  367. public:
  368. ResultObserver() = default;
  369. ResultObserver(const ResultObserver&) = delete;
  370. ResultObserver& operator=(const ResultObserver&) = delete;
  371. void Observe(int result) { results_.push_back(result); }
  372. const std::vector<int>& results() { return results_; }
  373. private:
  374. std::vector<int> results_;
  375. };
  376. // Fakes the TransportInfo passed to `URLRequest::Delegate::OnConnected()`.
  377. class URLRequestFakeTransportInfoJob : public net::URLRequestJob {
  378. public:
  379. // `transport_info` is subsequently passed to the `OnConnected()` callback
  380. // during `Start()`.
  381. // `second_transport_info`, if non-nullopt, is passed to the `OnConnected()`
  382. // callback during `ReadRawData()`.
  383. // `connected_callback_result_observer`, if non-nullptr, is notified of all
  384. // the results of calling `OnConnected()`.
  385. URLRequestFakeTransportInfoJob(
  386. net::URLRequest* request,
  387. net::TransportInfo transport_info,
  388. absl::optional<net::TransportInfo> second_transport_info,
  389. ResultObserver* connected_callback_result_observer)
  390. : URLRequestJob(request),
  391. transport_info_(std::move(transport_info)),
  392. second_transport_info_(std::move(second_transport_info)),
  393. connected_callback_result_observer_(
  394. connected_callback_result_observer) {}
  395. URLRequestFakeTransportInfoJob(const URLRequestFakeTransportInfoJob&) =
  396. delete;
  397. URLRequestFakeTransportInfoJob& operator=(
  398. const URLRequestFakeTransportInfoJob&) = delete;
  399. ~URLRequestFakeTransportInfoJob() override = default;
  400. // net::URLRequestJob implementation:
  401. void Start() override {
  402. base::ThreadTaskRunnerHandle::Get()->PostTask(
  403. FROM_HERE, base::BindOnce(&URLRequestFakeTransportInfoJob::StartAsync,
  404. weak_factory_.GetWeakPtr()));
  405. }
  406. int ReadRawData(net::IOBuffer* buf, int buf_size) override {
  407. if (!second_transport_info_) {
  408. return 0;
  409. }
  410. int result = NotifyConnected(
  411. *second_transport_info_, base::BindLambdaForTesting([](int result) {
  412. ADD_FAILURE() << "NotifyConnected() callback called with " << result;
  413. }));
  414. ObserveResult(result);
  415. return result;
  416. }
  417. private:
  418. void StartAsync() {
  419. // Simulate notifying caller of a connection. Call NotifyStartError() or
  420. // NotifyHeadersComplete() synchronously/asynchronously on error/success,
  421. // depending on return value and callback invocation.
  422. const int result = NotifyConnected(
  423. transport_info_,
  424. base::BindOnce(
  425. &URLRequestFakeTransportInfoJob::ConnectedCallbackComplete,
  426. base::Unretained(this)));
  427. // Wait for callback to be invoked in async case.
  428. if (result == net::ERR_IO_PENDING)
  429. return;
  430. ConnectedCallbackComplete(result);
  431. }
  432. void ConnectedCallbackComplete(int result) {
  433. ObserveResult(result);
  434. if (result != net::OK) {
  435. NotifyStartError(result);
  436. return;
  437. }
  438. NotifyHeadersComplete();
  439. }
  440. void ObserveResult(int result) {
  441. if (!connected_callback_result_observer_) {
  442. return;
  443. }
  444. connected_callback_result_observer_->Observe(result);
  445. }
  446. // The fake transport info we pass to `NotifyConnected()` during `Start()`.
  447. const net::TransportInfo transport_info_;
  448. // An optional fake transport info we pass to `NotifyConnected()` during
  449. // `ReadRawData()`.
  450. const absl::optional<net::TransportInfo> second_transport_info_;
  451. // An observer to be called with each result of calling `NotifyConnected()`.
  452. raw_ptr<ResultObserver> connected_callback_result_observer_;
  453. base::WeakPtrFactory<URLRequestFakeTransportInfoJob> weak_factory_{this};
  454. };
  455. // Intercepts URLRequestJob creation to a specific URL. All requests to this
  456. // URL will report being connected with a fake TransportInfo struct.
  457. class FakeTransportInfoInterceptor : public net::URLRequestInterceptor {
  458. public:
  459. // All intercepted requests will claim to be connected via |transport_info|.
  460. explicit FakeTransportInfoInterceptor(
  461. const net::TransportInfo& transport_info)
  462. : transport_info_(transport_info) {}
  463. // Sets a second transport info that will be passed to `OnConnected()` when
  464. // the response data is read.
  465. void SetSecondTransportInfo(const net::TransportInfo& transport_info) {
  466. second_transport_info_ = transport_info;
  467. }
  468. // Sets up `observer` to be notified of the result of all future calls to
  469. // `NotifyConnected` from within `URLRequestFakeTransportInfoJob`.
  470. //
  471. // `observer` must outlive this instance.
  472. void SetConnectedCallbackResultObserver(ResultObserver* observer) {
  473. connected_callback_result_observer_ = observer;
  474. }
  475. ~FakeTransportInfoInterceptor() override = default;
  476. FakeTransportInfoInterceptor(const FakeTransportInfoInterceptor&) = delete;
  477. FakeTransportInfoInterceptor& operator=(const FakeTransportInfoInterceptor&) =
  478. delete;
  479. // URLRequestInterceptor implementation:
  480. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  481. net::URLRequest* request) const override {
  482. return std::make_unique<URLRequestFakeTransportInfoJob>(
  483. request, transport_info_, second_transport_info_,
  484. connected_callback_result_observer_);
  485. }
  486. private:
  487. const net::TransportInfo transport_info_;
  488. absl::optional<net::TransportInfo> second_transport_info_;
  489. raw_ptr<ResultObserver> connected_callback_result_observer_ = nullptr;
  490. };
  491. // Returns a maximally-restrictive security state for use in tests.
  492. mojom::ClientSecurityStatePtr NewSecurityState() {
  493. auto result = mojom::ClientSecurityState::New();
  494. result->is_web_secure_context = false;
  495. result->private_network_request_policy =
  496. mojom::PrivateNetworkRequestPolicy::kBlock;
  497. result->ip_address_space = mojom::IPAddressSpace::kUnknown;
  498. return result;
  499. }
  500. CorsErrorStatus InsecurePrivateNetworkCorsErrorStatus(
  501. mojom::IPAddressSpace resource_address_space) {
  502. return CorsErrorStatus(mojom::CorsError::kInsecurePrivateNetwork,
  503. mojom::IPAddressSpace::kUnknown,
  504. resource_address_space);
  505. }
  506. // Returns whether monitoring was successfully set up.
  507. // |*output_sample| needs to stay valid until monitoring is stopped.
  508. std::unique_ptr<base::StatisticsRecorder::ScopedHistogramSampleObserver>
  509. StartMonitorBodyReadFromNetBeforePausedHistogram(
  510. const base::RepeatingClosure& quit_closure,
  511. base::HistogramBase::Sample* output_sample) {
  512. return std::make_unique<
  513. base::StatisticsRecorder::ScopedHistogramSampleObserver>(
  514. kBodyReadFromNetBeforePausedHistogram,
  515. base::BindRepeating(
  516. [](const base::RepeatingClosure& quit_closure,
  517. base::HistogramBase::Sample* output, const char* histogram_name,
  518. uint64_t name_hash, base::HistogramBase::Sample sample) {
  519. *output = sample;
  520. quit_closure.Run();
  521. },
  522. quit_closure, output_sample));
  523. }
  524. std::string CookieOrLineToString(const mojom::CookieOrLinePtr& cookie_or_line) {
  525. switch (cookie_or_line->which()) {
  526. case mojom::CookieOrLine::Tag::kCookie:
  527. return base::StrCat({
  528. cookie_or_line->get_cookie().Name(),
  529. "=",
  530. cookie_or_line->get_cookie().Value(),
  531. });
  532. case mojom::CookieOrLine::Tag::kCookieString:
  533. return cookie_or_line->get_cookie_string();
  534. }
  535. }
  536. MATCHER_P2(CookieOrLine, string, type, "") {
  537. return type == arg->which() &&
  538. testing::ExplainMatchResult(string, CookieOrLineToString(arg),
  539. result_listener);
  540. }
  541. } // namespace
  542. class MockAcceptCHFrameObserver : public mojom::AcceptCHFrameObserver {
  543. public:
  544. MockAcceptCHFrameObserver() = default;
  545. ~MockAcceptCHFrameObserver() override = default;
  546. mojo::PendingRemote<mojom::AcceptCHFrameObserver> Bind() {
  547. mojo::PendingRemote<mojom::AcceptCHFrameObserver> remote;
  548. receivers_.Add(this, remote.InitWithNewPipeAndPassReceiver());
  549. return remote;
  550. }
  551. void OnAcceptCHFrameReceived(
  552. const url::Origin& origin,
  553. const std::vector<network::mojom::WebClientHintsType>& accept_ch_frame,
  554. OnAcceptCHFrameReceivedCallback callback) override {
  555. called_ = true;
  556. accept_ch_frame_ = accept_ch_frame;
  557. std::move(callback).Run(net::OK);
  558. }
  559. void Clone(mojo::PendingReceiver<network::mojom::AcceptCHFrameObserver>
  560. listener) override {
  561. receivers_.Add(this, std::move(listener));
  562. }
  563. bool called() const { return called_; }
  564. const std::vector<network::mojom::WebClientHintsType>& accept_ch_frame()
  565. const {
  566. return accept_ch_frame_;
  567. }
  568. private:
  569. bool called_ = false;
  570. std::vector<network::mojom::WebClientHintsType> accept_ch_frame_;
  571. mojo::ReceiverSet<mojom::AcceptCHFrameObserver> receivers_;
  572. };
  573. class URLLoaderTest : public testing::Test {
  574. public:
  575. URLLoaderTest()
  576. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO) {
  577. scoped_refptr<net::X509Certificate> quic_root = net::ImportCertFromFile(
  578. net::GetTestCertsDirectory().AppendASCII("quic-root.pem"));
  579. if (quic_root)
  580. scoped_test_root_.Reset({quic_root});
  581. else
  582. ADD_FAILURE();
  583. net::QuicSimpleTestServer::Start();
  584. net::URLRequestFailedJob::AddUrlHandler();
  585. scoped_feature_list_.InitWithFeatures(
  586. /*enabled_features=*/{features::kAcceptCHFrame,
  587. net::features::kRecordRadioWakeupTrigger},
  588. /*disabled_features=*/{});
  589. }
  590. ~URLLoaderTest() override {
  591. net::URLRequestFilter::GetInstance()->ClearHandlers();
  592. }
  593. void SetUp() override {
  594. net::HttpNetworkSessionParams params;
  595. auto quic_context = std::make_unique<net::QuicContext>();
  596. quic_context->params()->origins_to_force_quic_on.insert(
  597. net::HostPortPair(net::QuicSimpleTestServer::GetHost(),
  598. net::QuicSimpleTestServer::GetPort()));
  599. params.enable_quic = true;
  600. net::URLRequestContextBuilder context_builder;
  601. context_builder.set_http_network_session_params(params);
  602. context_builder.set_quic_context(std::move(quic_context));
  603. context_builder.set_proxy_resolution_service(
  604. net::ConfiguredProxyResolutionService::CreateDirect());
  605. auto test_network_delegate = std::make_unique<net::TestNetworkDelegate>();
  606. unowned_test_network_delegate_ = test_network_delegate.get();
  607. context_builder.set_network_delegate(std::move(test_network_delegate));
  608. context_builder.set_client_socket_factory_for_testing(GetSocketFactory());
  609. url_request_context_ = context_builder.Build();
  610. context().set_url_request_context(url_request_context_.get());
  611. resource_scheduler_client_ = base::MakeRefCounted<ResourceSchedulerClient>(
  612. kResourceSchedulerClientId, IsBrowserInitiated(false),
  613. &resource_scheduler_,
  614. url_request_context_->network_quality_estimator());
  615. context().set_resource_scheduler_client(resource_scheduler_client_.get());
  616. test_server_.AddDefaultHandlers(
  617. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  618. // This Unretained is safe because test_server_ is owned by |this|.
  619. test_server_.RegisterRequestMonitor(
  620. base::BindRepeating(&URLLoaderTest::Monitor, base::Unretained(this)));
  621. ASSERT_TRUE(test_server_.Start());
  622. // Set up a scoped host resolver so that |kInsecureHost| will resolve to
  623. // the loopback address and will let us access |test_server_|.
  624. scoped_refptr<net::RuleBasedHostResolverProc> mock_resolver_proc =
  625. base::MakeRefCounted<net::RuleBasedHostResolverProc>(nullptr);
  626. mock_resolver_proc->AddIPLiteralRuleWithDnsAliases(
  627. kHostnameWithAliases, "127.0.0.1", {"alias1", "alias2", "host"});
  628. mock_resolver_proc->AddRule("*", "127.0.0.1");
  629. mock_host_resolver_ = std::make_unique<net::ScopedDefaultHostResolverProc>(
  630. mock_resolver_proc.get());
  631. }
  632. void TearDown() override {
  633. context().set_resource_scheduler_client(nullptr);
  634. url_request_context_.reset();
  635. net::QuicSimpleTestServer::Shutdown();
  636. }
  637. // Attempts to load |url| and returns the resulting error code.
  638. [[nodiscard]] int Load(const GURL& url, std::string* body = nullptr) {
  639. DCHECK(!ran_);
  640. ResourceRequest request =
  641. CreateResourceRequest(!request_body_ ? "GET" : "POST", url);
  642. if (request_body_)
  643. request.request_body = request_body_;
  644. request.trusted_params->client_security_state.Swap(
  645. &request_client_security_state_);
  646. request.headers.MergeFrom(additional_headers_);
  647. request.target_ip_address_space = target_ip_address_space_;
  648. return LoadRequest(request, body);
  649. }
  650. // Attempts to load |request| and returns the resulting error code. If |body|
  651. // is non-NULL, also attempts to read the response body. The advantage of
  652. // using |body| instead of calling ReadBody() after Load is that it will load
  653. // the response body before URLLoader is complete, so URLLoader completion
  654. // won't block on trying to write the body buffer.
  655. [[nodiscard]] int LoadRequest(const ResourceRequest& request,
  656. std::string* body = nullptr,
  657. bool is_trusted = true) {
  658. uint32_t options = mojom::kURLLoadOptionNone;
  659. if (send_ssl_with_response_)
  660. options |= mojom::kURLLoadOptionSendSSLInfoWithResponse;
  661. if (sniff_)
  662. options |= mojom::kURLLoadOptionSniffMimeType;
  663. if (send_ssl_for_cert_error_)
  664. options |= mojom::kURLLoadOptionSendSSLInfoForCertificateError;
  665. std::unique_ptr<TestNetworkContextClient> network_context_client;
  666. std::unique_ptr<TestURLLoaderNetworkObserver> url_loader_network_observer;
  667. if (allow_file_uploads_) {
  668. network_context_client = std::make_unique<TestNetworkContextClient>();
  669. network_context_client->set_upload_files_invalid(upload_files_invalid_);
  670. network_context_client->set_ignore_last_upload_file(
  671. ignore_last_upload_file_);
  672. }
  673. context().set_network_context_client(network_context_client.get());
  674. if (ignore_certificate_errors_) {
  675. url_loader_network_observer =
  676. std::make_unique<TestURLLoaderNetworkObserver>();
  677. url_loader_network_observer->set_ignore_certificate_errors(true);
  678. }
  679. base::RunLoop delete_run_loop;
  680. mojo::Remote<mojom::URLLoader> loader;
  681. std::unique_ptr<URLLoader> url_loader;
  682. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  683. context().mutable_factory_params().is_corb_enabled = corb_enabled_;
  684. context().mutable_factory_params().client_security_state.Swap(
  685. &factory_client_security_state_);
  686. context().mutable_factory_params().isolation_info =
  687. net::IsolationInfo::CreateForInternalRequest(
  688. url::Origin::Create(request.url));
  689. context().mutable_factory_params().is_trusted = is_trusted;
  690. url_loader = std::make_unique<URLLoader>(
  691. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  692. loader.BindNewPipeAndPassReceiver(), options, request,
  693. client_.CreateRemote(), nullptr /* sync_url_loader_client */,
  694. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  695. 0 /* keepalive_request_size */, nullptr,
  696. nullptr /* trust_token_helper */,
  697. mojo::NullRemote() /* cookie_observer */,
  698. url_loader_network_observer
  699. ? url_loader_network_observer->Bind()
  700. : mojo::NullRemote() /* url_loader_network_observer */,
  701. devtools_observer_ ? devtools_observer_->Bind() : mojo::NullRemote(),
  702. accept_ch_frame_observer_ ? accept_ch_frame_observer_->Bind()
  703. : mojo::NullRemote(),
  704. /*third_party_cookies_enabled=*/true);
  705. ran_ = true;
  706. devtools_observer_ = nullptr;
  707. accept_ch_frame_observer_ = nullptr;
  708. if (expect_redirect_) {
  709. client_.RunUntilRedirectReceived();
  710. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  711. }
  712. if (body) {
  713. client_.RunUntilResponseBodyArrived();
  714. *body = ReadBody();
  715. }
  716. client_.RunUntilComplete();
  717. if (body) {
  718. EXPECT_EQ(body->size(),
  719. static_cast<size_t>(
  720. client()->completion_status().decoded_body_length));
  721. }
  722. delete_run_loop.Run();
  723. return client_.completion_status().error_code;
  724. }
  725. void LoadAndCompareFile(const std::string& path) {
  726. base::FilePath file = GetTestFilePath(path);
  727. std::string expected;
  728. if (!base::ReadFileToString(file, &expected)) {
  729. ADD_FAILURE() << "File not found: " << file.value();
  730. return;
  731. }
  732. std::string body;
  733. EXPECT_EQ(net::OK,
  734. Load(test_server()->GetURL(std::string("/") + path), &body));
  735. EXPECT_EQ(expected, body);
  736. // The file isn't compressed, so both encoded and decoded body lengths
  737. // should match the read body length.
  738. EXPECT_EQ(
  739. expected.size(),
  740. static_cast<size_t>(client()->completion_status().decoded_body_length));
  741. EXPECT_EQ(
  742. expected.size(),
  743. static_cast<size_t>(client()->completion_status().encoded_body_length));
  744. // Over the wire length should include headers, so should be longer.
  745. // TODO(mmenke): Worth adding better tests for encoded_data_length?
  746. EXPECT_LT(
  747. expected.size(),
  748. static_cast<size_t>(client()->completion_status().encoded_data_length));
  749. }
  750. // Adds a MultipleWritesInterceptor for MultipleWritesInterceptor::GetURL()
  751. // that results in seeing each element of |packets| read individually, and
  752. // then a final read that returns |net_error|. The URLRequestInterceptor is
  753. // not removed from URLFilter until the test fixture is torn down.
  754. // |async_reads| indicates whether all reads (including those for |packets|
  755. // and |net_error|) complete asynchronously or not.
  756. void AddMultipleWritesInterceptor(std::list<std::string> packets,
  757. net::Error net_error,
  758. bool async_reads) {
  759. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  760. MultipleWritesInterceptor::GetURL(),
  761. std::unique_ptr<net::URLRequestInterceptor>(
  762. new MultipleWritesInterceptor(std::move(packets), net_error,
  763. async_reads)));
  764. }
  765. // Adds an EternalSyncReadsInterceptor for
  766. // EternalSyncReadsInterceptor::GetURL(), which creates URLRequestJobs where
  767. // all reads return a sync byte that's read synchronously.
  768. void AddEternalSyncReadsInterceptor() {
  769. net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
  770. "http", EternalSyncReadsInterceptor::GetHostName(),
  771. std::make_unique<EternalSyncReadsInterceptor>());
  772. }
  773. // If |second| is empty, then it's ignored.
  774. void LoadPacketsAndVerifyContents(const std::string& first,
  775. const std::string& second) {
  776. EXPECT_FALSE(first.empty());
  777. std::list<std::string> packets;
  778. packets.push_back(first);
  779. if (!second.empty())
  780. packets.push_back(second);
  781. AddMultipleWritesInterceptor(std::move(packets), net::OK,
  782. false /* async_reads */);
  783. std::string expected_body = first + second;
  784. std::string actual_body;
  785. EXPECT_EQ(net::OK, Load(MultipleWritesInterceptor::GetURL(), &actual_body));
  786. EXPECT_EQ(actual_body, expected_body);
  787. }
  788. net::EmbeddedTestServer* test_server() { return &test_server_; }
  789. net::URLRequestContext* url_request_context() {
  790. return url_request_context_.get();
  791. }
  792. URLLoaderContextForTests& context() { return url_loader_context_for_tests_; }
  793. TestURLLoaderClient* client() { return &client_; }
  794. // Returns the path of the requested file in the test data directory.
  795. base::FilePath GetTestFilePath(const std::string& file_name) {
  796. base::FilePath file_path;
  797. base::PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
  798. file_path = file_path.Append(FILE_PATH_LITERAL("services"));
  799. file_path = file_path.Append(FILE_PATH_LITERAL("test"));
  800. file_path = file_path.Append(FILE_PATH_LITERAL("data"));
  801. return file_path.AppendASCII(file_name);
  802. }
  803. base::File OpenFileForUpload(const base::FilePath& file_path) {
  804. int open_flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
  805. #if BUILDFLAG(IS_WIN)
  806. open_flags |= base::File::FLAG_ASYNC;
  807. #endif // BUILDFLAG(IS_WIN)
  808. base::File file(file_path, open_flags);
  809. EXPECT_TRUE(file.IsValid());
  810. return file;
  811. }
  812. ResourceScheduler* resource_scheduler() { return &resource_scheduler_; }
  813. scoped_refptr<ResourceSchedulerClient> resource_scheduler_client() {
  814. return resource_scheduler_client_;
  815. }
  816. // Configure how Load() works.
  817. void allow_file_uploads() {
  818. DCHECK(!ran_);
  819. allow_file_uploads_ = true;
  820. }
  821. void set_upload_files_invalid(bool upload_files_invalid) {
  822. DCHECK(!ran_);
  823. upload_files_invalid_ = upload_files_invalid;
  824. }
  825. void set_ignore_last_upload_file(bool ignore_last_upload_file) {
  826. DCHECK(!ran_);
  827. ignore_last_upload_file_ = ignore_last_upload_file;
  828. }
  829. void set_sniff() {
  830. DCHECK(!ran_);
  831. sniff_ = true;
  832. }
  833. void set_send_ssl_with_response() {
  834. DCHECK(!ran_);
  835. send_ssl_with_response_ = true;
  836. }
  837. void set_send_ssl_for_cert_error() {
  838. DCHECK(!ran_);
  839. send_ssl_for_cert_error_ = true;
  840. }
  841. void set_ignore_certificate_errors() {
  842. DCHECK(!ran_);
  843. ignore_certificate_errors_ = true;
  844. }
  845. void set_expect_redirect() {
  846. DCHECK(!ran_);
  847. expect_redirect_ = true;
  848. }
  849. void set_factory_client_security_state(mojom::ClientSecurityStatePtr state) {
  850. factory_client_security_state_ = std::move(state);
  851. }
  852. void set_request_client_security_state(mojom::ClientSecurityStatePtr state) {
  853. request_client_security_state_ = std::move(state);
  854. }
  855. void set_devtools_observer_for_next_request(MockDevToolsObserver* observer) {
  856. devtools_observer_ = observer;
  857. }
  858. void set_request_body(scoped_refptr<ResourceRequestBody> request_body) {
  859. request_body_ = request_body;
  860. }
  861. void set_additional_headers(const net::HttpRequestHeaders& headers) {
  862. additional_headers_ = headers;
  863. }
  864. void set_target_ip_address_space(mojom::IPAddressSpace address_space) {
  865. target_ip_address_space_ = address_space;
  866. }
  867. void set_accept_ch_frame_observer_for_next_request(
  868. MockAcceptCHFrameObserver* observer) {
  869. accept_ch_frame_observer_ = observer;
  870. }
  871. // Convenience methods after calling Load();
  872. std::string mime_type() const {
  873. DCHECK(ran_);
  874. return client_.response_head()->mime_type;
  875. }
  876. bool did_mime_sniff() const {
  877. DCHECK(ran_);
  878. return client_.response_head()->did_mime_sniff;
  879. }
  880. const absl::optional<net::SSLInfo>& ssl_info() const {
  881. DCHECK(ran_);
  882. return client_.ssl_info();
  883. }
  884. // Reads the response body from client()->response_body() until the channel is
  885. // closed. Expects client()->response_body() to already be populated, and
  886. // non-NULL.
  887. std::string ReadBody() {
  888. std::string body;
  889. while (true) {
  890. MojoHandle consumer = client()->response_body().value();
  891. const void* buffer;
  892. uint32_t num_bytes;
  893. MojoResult rv = MojoBeginReadData(consumer, nullptr, &buffer, &num_bytes);
  894. // If no data has been received yet, spin the message loop until it has.
  895. if (rv == MOJO_RESULT_SHOULD_WAIT) {
  896. mojo::SimpleWatcher watcher(
  897. FROM_HERE, mojo::SimpleWatcher::ArmingPolicy::AUTOMATIC,
  898. base::SequencedTaskRunnerHandle::Get());
  899. base::RunLoop run_loop;
  900. watcher.Watch(
  901. client()->response_body(),
  902. MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
  903. MOJO_WATCH_CONDITION_SATISFIED,
  904. base::BindRepeating(
  905. [](base::RepeatingClosure quit, MojoResult result,
  906. const mojo::HandleSignalsState& state) { quit.Run(); },
  907. run_loop.QuitClosure()));
  908. run_loop.Run();
  909. continue;
  910. }
  911. // The pipe was closed.
  912. if (rv == MOJO_RESULT_FAILED_PRECONDITION)
  913. return body;
  914. CHECK_EQ(rv, MOJO_RESULT_OK);
  915. body.append(static_cast<const char*>(buffer), num_bytes);
  916. MojoEndReadData(consumer, num_bytes, nullptr);
  917. }
  918. }
  919. std::string ReadAvailableBody() {
  920. MojoHandle consumer = client()->response_body().value();
  921. uint32_t num_bytes = 0;
  922. MojoReadDataOptions options;
  923. options.struct_size = sizeof(options);
  924. options.flags = MOJO_READ_DATA_FLAG_QUERY;
  925. MojoResult result = MojoReadData(consumer, &options, nullptr, &num_bytes);
  926. CHECK_EQ(MOJO_RESULT_OK, result);
  927. if (num_bytes == 0)
  928. return std::string();
  929. std::vector<char> buffer(num_bytes);
  930. result = MojoReadData(consumer, nullptr, buffer.data(), &num_bytes);
  931. CHECK_EQ(MOJO_RESULT_OK, result);
  932. CHECK_EQ(num_bytes, buffer.size());
  933. return std::string(buffer.data(), buffer.size());
  934. }
  935. const net::test_server::HttpRequest& sent_request() const {
  936. return sent_request_;
  937. }
  938. net::TestNetworkDelegate* test_network_delegate() {
  939. return unowned_test_network_delegate_;
  940. }
  941. void RunUntilIdle() { task_environment_.RunUntilIdle(); }
  942. static constexpr int kProcessId = 4;
  943. static constexpr int kRouteId = 8;
  944. static constexpr ResourceScheduler::ClientId kResourceSchedulerClientId{99};
  945. // |OnServerReceivedRequest| allows subclasses to register additional logic to
  946. // execute once a request reaches the test server.
  947. virtual void OnServerReceivedRequest(const net::test_server::HttpRequest&) {}
  948. // Lets subclasses inject a mock ClientSocketFactory.
  949. virtual net::ClientSocketFactory* GetSocketFactory() { return nullptr; }
  950. protected:
  951. void Monitor(const net::test_server::HttpRequest& request) {
  952. sent_request_ = request;
  953. OnServerReceivedRequest(request);
  954. }
  955. base::test::ScopedFeatureList scoped_feature_list_;
  956. base::test::TaskEnvironment task_environment_;
  957. net::ScopedTestRoot scoped_test_root_;
  958. net::EmbeddedTestServer test_server_;
  959. std::unique_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_;
  960. raw_ptr<net::TestNetworkDelegate>
  961. unowned_test_network_delegate_; // owned by |url_request_context_|
  962. std::unique_ptr<net::URLRequestContext> url_request_context_;
  963. URLLoaderContextForTests url_loader_context_for_tests_;
  964. ResourceScheduler resource_scheduler_;
  965. scoped_refptr<ResourceSchedulerClient> resource_scheduler_client_;
  966. // Options applied to the created request in Load().
  967. bool allow_file_uploads_ = false;
  968. bool upload_files_invalid_ = false;
  969. bool ignore_last_upload_file_ = false;
  970. bool sniff_ = false;
  971. bool send_ssl_with_response_ = false;
  972. bool send_ssl_for_cert_error_ = false;
  973. bool ignore_certificate_errors_ = false;
  974. bool expect_redirect_ = false;
  975. mojom::ClientSecurityStatePtr factory_client_security_state_;
  976. mojom::ClientSecurityStatePtr request_client_security_state_;
  977. raw_ptr<MockDevToolsObserver> devtools_observer_ = nullptr;
  978. scoped_refptr<ResourceRequestBody> request_body_;
  979. net::HttpRequestHeaders additional_headers_;
  980. mojom::IPAddressSpace target_ip_address_space_ =
  981. mojom::IPAddressSpace::kUnknown;
  982. bool corb_enabled_ = false;
  983. // Used to ensure that methods are called either before or after a request is
  984. // made, since the test fixture is meant to be used only once.
  985. bool ran_ = false;
  986. net::test_server::HttpRequest sent_request_;
  987. TestURLLoaderClient client_;
  988. raw_ptr<MockAcceptCHFrameObserver> accept_ch_frame_observer_ = nullptr;
  989. };
  990. class URLLoaderMockSocketTest : public URLLoaderTest {
  991. public:
  992. URLLoaderMockSocketTest() = default;
  993. ~URLLoaderMockSocketTest() override = default;
  994. // Lets subclasses inject mock ClientSocketFactories.
  995. net::ClientSocketFactory* GetSocketFactory() override {
  996. return &socket_factory_;
  997. }
  998. protected:
  999. net::MockClientSocketFactory socket_factory_;
  1000. };
  1001. constexpr int URLLoaderTest::kProcessId;
  1002. constexpr int URLLoaderTest::kRouteId;
  1003. TEST_F(URLLoaderTest, Basic) {
  1004. LoadAndCompareFile("simple_page.html");
  1005. }
  1006. TEST_F(URLLoaderTest, Empty) {
  1007. LoadAndCompareFile("empty.html");
  1008. }
  1009. TEST_F(URLLoaderTest, BasicSSL) {
  1010. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  1011. https_server.ServeFilesFromSourceDirectory(
  1012. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  1013. ASSERT_TRUE(https_server.Start());
  1014. GURL url = https_server.GetURL("/simple_page.html");
  1015. set_send_ssl_with_response();
  1016. EXPECT_EQ(net::OK, Load(url));
  1017. ASSERT_TRUE(!!ssl_info());
  1018. ASSERT_TRUE(!!ssl_info()->cert);
  1019. ASSERT_TRUE(https_server.GetCertificate()->EqualsExcludingChain(
  1020. ssl_info()->cert.get()));
  1021. }
  1022. TEST_F(URLLoaderTest, SSLSentOnlyWhenRequested) {
  1023. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  1024. https_server.ServeFilesFromSourceDirectory(
  1025. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  1026. ASSERT_TRUE(https_server.Start());
  1027. GURL url = https_server.GetURL("/simple_page.html");
  1028. EXPECT_EQ(net::OK, Load(url));
  1029. ASSERT_FALSE(!!ssl_info());
  1030. }
  1031. // This test verifies that when the URLLoaderFactory's parameters are missing
  1032. // a client security state, requests to local network resources are authorized.
  1033. TEST_F(URLLoaderTest, MissingClientSecurityStateIsOk) {
  1034. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1035. }
  1036. // This test verifies that when the request's `target_ip_address_space` matches
  1037. // the resource's IP address space, then the request is allowed even if it
  1038. // would otherwise be blocked by policy.
  1039. TEST_F(URLLoaderTest, MatchingTargetIPAddressSpaceIsOk) {
  1040. auto client_security_state = NewSecurityState();
  1041. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1042. set_factory_client_security_state(std::move(client_security_state));
  1043. set_target_ip_address_space(mojom::IPAddressSpace::kLocal);
  1044. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1045. }
  1046. // This test verifies that when the request's `target_ip_address_space` does not
  1047. // match the resource's IP address space, and the policy is `kPreflightWarn`,
  1048. // then the request is not blocked.
  1049. TEST_F(URLLoaderTest, MismatchingTargetIPAddressSpaceWarnIsNotBlocked) {
  1050. auto client_security_state = NewSecurityState();
  1051. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1052. client_security_state->private_network_request_policy =
  1053. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1054. set_factory_client_security_state(std::move(client_security_state));
  1055. set_target_ip_address_space(mojom::IPAddressSpace::kPrivate);
  1056. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1057. }
  1058. // This test verifies that when the request's `target_ip_address_space` does not
  1059. // match the resource's IP address space, and the policy is `kPreflightBlock`,
  1060. // then the request is blocked.
  1061. TEST_F(URLLoaderTest, MismatchingTargetIPAddressSpaceIsBlocked) {
  1062. auto client_security_state = NewSecurityState();
  1063. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1064. client_security_state->private_network_request_policy =
  1065. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1066. set_factory_client_security_state(std::move(client_security_state));
  1067. set_target_ip_address_space(mojom::IPAddressSpace::kPrivate);
  1068. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1069. IsError(net::ERR_FAILED));
  1070. EXPECT_THAT(
  1071. client()->completion_status().cors_error_status,
  1072. Optional(CorsErrorStatus(mojom::CorsError::kInvalidPrivateNetworkAccess,
  1073. mojom::IPAddressSpace::kPrivate,
  1074. mojom::IPAddressSpace::kLocal)));
  1075. }
  1076. // This test verifies that when the request's `target_ip_address_space` does not
  1077. // match the resource's IP address space, and the policy is `kPreflightBlock`,
  1078. // then `URLLoader::OnConnected()` returns the right error code. This error code
  1079. // causes any cache entry in use to be invalidated.
  1080. TEST_F(URLLoaderTest, MismatchingTargetIPAddressSpaceErrorCode) {
  1081. auto client_security_state = NewSecurityState();
  1082. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1083. client_security_state->private_network_request_policy =
  1084. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1085. set_factory_client_security_state(std::move(client_security_state));
  1086. set_target_ip_address_space(mojom::IPAddressSpace::kPrivate);
  1087. ResultObserver connected_callback_result_observer;
  1088. net::TransportInfo info = net::DefaultTransportInfo();
  1089. info.endpoint = net::IPEndPoint(net::IPAddress(127, 0, 0, 1), 80);
  1090. auto interceptor = std::make_unique<FakeTransportInfoInterceptor>(info);
  1091. interceptor->SetConnectedCallbackResultObserver(
  1092. &connected_callback_result_observer);
  1093. const GURL url("http://fake-endpoint");
  1094. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  1095. url, std::move(interceptor));
  1096. EXPECT_THAT(Load(url), IsError(net::ERR_FAILED));
  1097. EXPECT_THAT(
  1098. client()->completion_status().cors_error_status,
  1099. Optional(CorsErrorStatus(mojom::CorsError::kInvalidPrivateNetworkAccess,
  1100. mojom::IPAddressSpace::kPrivate,
  1101. mojom::IPAddressSpace::kLocal)));
  1102. EXPECT_THAT(connected_callback_result_observer.results(),
  1103. ElementsAre(IsError(net::ERR_INCONSISTENT_IP_ADDRESS_SPACE)));
  1104. }
  1105. // This test verifies that when the request calls `URLLoader::OnConnected()`
  1106. // twice with endpoints belonging to different IP address spaces, but the
  1107. // private network request policy is `kPreflightWarn`, then the request is not
  1108. // blocked.
  1109. TEST_F(URLLoaderTest, InconsistentIPAddressSpaceWarnIsNotBlocked) {
  1110. auto client_security_state = NewSecurityState();
  1111. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1112. client_security_state->is_web_secure_context = true;
  1113. client_security_state->private_network_request_policy =
  1114. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1115. set_factory_client_security_state(std::move(client_security_state));
  1116. net::TransportInfo info = net::DefaultTransportInfo();
  1117. info.endpoint = net::IPEndPoint(net::IPAddress(1, 2, 3, 4), 80);
  1118. auto interceptor = std::make_unique<FakeTransportInfoInterceptor>(info);
  1119. info.endpoint = net::IPEndPoint(net::IPAddress(127, 0, 0, 1), 80);
  1120. interceptor->SetSecondTransportInfo(info);
  1121. const GURL url("http://fake-endpoint");
  1122. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  1123. url, std::move(interceptor));
  1124. EXPECT_THAT(Load(url), IsOk());
  1125. }
  1126. // This test verifies that when the request calls `URLLoader::OnConnected()`
  1127. // twice with endpoints belonging to different IP address spaces, the request
  1128. // fails. In that case `URLLoader::OnConnected()` returns the right error code,
  1129. // which causes any cache entry in use to be invalidated.
  1130. TEST_F(URLLoaderTest, InconsistentIPAddressSpaceIsBlocked) {
  1131. auto client_security_state = NewSecurityState();
  1132. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1133. client_security_state->is_web_secure_context = true;
  1134. client_security_state->private_network_request_policy =
  1135. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1136. set_factory_client_security_state(std::move(client_security_state));
  1137. ResultObserver connected_callback_result_observer;
  1138. net::TransportInfo info = net::DefaultTransportInfo();
  1139. info.endpoint = net::IPEndPoint(net::IPAddress(1, 2, 3, 4), 80);
  1140. auto interceptor = std::make_unique<FakeTransportInfoInterceptor>(info);
  1141. info.endpoint = net::IPEndPoint(net::IPAddress(127, 0, 0, 1), 80);
  1142. interceptor->SetSecondTransportInfo(info);
  1143. interceptor->SetConnectedCallbackResultObserver(
  1144. &connected_callback_result_observer);
  1145. const GURL url("http://fake-endpoint");
  1146. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  1147. url, std::move(interceptor));
  1148. EXPECT_THAT(Load(url), IsError(net::ERR_FAILED));
  1149. EXPECT_THAT(
  1150. client()->completion_status().cors_error_status,
  1151. Optional(CorsErrorStatus(mojom::CorsError::kInvalidPrivateNetworkAccess,
  1152. // TODO(https://crbug.com/1279376): Expect
  1153. // `kPublic` here instead, for better debugging.
  1154. mojom::IPAddressSpace::kUnknown,
  1155. mojom::IPAddressSpace::kLocal)));
  1156. // The first connection was fine, but the second was inconsistent.
  1157. EXPECT_THAT(connected_callback_result_observer.results(),
  1158. ElementsAre(IsError(net::OK),
  1159. IsError(net::ERR_INCONSISTENT_IP_ADDRESS_SPACE)));
  1160. }
  1161. // These tests verify that requests from both secure and non-secure contexts to
  1162. // an IP in the `kLocal` address space are only blocked when the policy is
  1163. // `kBlock` and the initiator's address space is not `kLocal`.
  1164. //
  1165. // NOTE: These tests exercise the same codepath as
  1166. // URLLoaderFakeTransportInfoTest below, except they use real URLRequestJob and
  1167. // HttpTransaction implementations for higher confidence in the correctness of
  1168. // the whole stack. OTOH, using an embedded test server prevents us from mocking
  1169. // out the endpoint IP address.
  1170. TEST_F(URLLoaderTest, SecureUnknownToLocalBlock) {
  1171. auto client_security_state = NewSecurityState();
  1172. client_security_state->is_web_secure_context = true;
  1173. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1174. set_factory_client_security_state(std::move(client_security_state));
  1175. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1176. IsError(net::ERR_FAILED));
  1177. EXPECT_THAT(client()->completion_status().cors_error_status,
  1178. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1179. mojom::IPAddressSpace::kLocal)));
  1180. }
  1181. TEST_F(URLLoaderTest, SecureUnknownToLocalWarn) {
  1182. auto client_security_state = NewSecurityState();
  1183. client_security_state->is_web_secure_context = true;
  1184. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1185. client_security_state->private_network_request_policy =
  1186. mojom::PrivateNetworkRequestPolicy::kWarn;
  1187. set_factory_client_security_state(std::move(client_security_state));
  1188. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1189. }
  1190. TEST_F(URLLoaderTest, SecureUnknownToLocalAllow) {
  1191. auto client_security_state = NewSecurityState();
  1192. client_security_state->is_web_secure_context = true;
  1193. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1194. client_security_state->private_network_request_policy =
  1195. mojom::PrivateNetworkRequestPolicy::kAllow;
  1196. set_factory_client_security_state(std::move(client_security_state));
  1197. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1198. }
  1199. TEST_F(URLLoaderTest, SecureUnknownToLocalPreflightWarn) {
  1200. auto client_security_state = NewSecurityState();
  1201. client_security_state->is_web_secure_context = true;
  1202. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1203. client_security_state->private_network_request_policy =
  1204. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1205. set_factory_client_security_state(std::move(client_security_state));
  1206. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1207. IsError(net::ERR_FAILED));
  1208. EXPECT_THAT(
  1209. client()->completion_status().cors_error_status,
  1210. Optional(CorsErrorStatus(
  1211. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1212. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1213. }
  1214. TEST_F(URLLoaderTest, SecureUnknownToLocalPreflightBlock) {
  1215. auto client_security_state = NewSecurityState();
  1216. client_security_state->is_web_secure_context = true;
  1217. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1218. client_security_state->private_network_request_policy =
  1219. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1220. set_factory_client_security_state(std::move(client_security_state));
  1221. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1222. IsError(net::ERR_FAILED));
  1223. EXPECT_THAT(
  1224. client()->completion_status().cors_error_status,
  1225. Optional(CorsErrorStatus(
  1226. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1227. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1228. }
  1229. TEST_F(URLLoaderTest, NonSecureUnknownToLocalBlock) {
  1230. auto client_security_state = NewSecurityState();
  1231. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1232. set_factory_client_security_state(std::move(client_security_state));
  1233. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1234. IsError(net::ERR_FAILED));
  1235. EXPECT_THAT(client()->completion_status().cors_error_status,
  1236. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1237. mojom::IPAddressSpace::kLocal)));
  1238. }
  1239. TEST_F(URLLoaderTest, NonSecureUnknownToLocalWarn) {
  1240. auto client_security_state = NewSecurityState();
  1241. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1242. client_security_state->private_network_request_policy =
  1243. mojom::PrivateNetworkRequestPolicy::kWarn;
  1244. set_factory_client_security_state(std::move(client_security_state));
  1245. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1246. }
  1247. TEST_F(URLLoaderTest, NonSecureUnknownToLocalAllow) {
  1248. auto client_security_state = NewSecurityState();
  1249. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1250. client_security_state->private_network_request_policy =
  1251. mojom::PrivateNetworkRequestPolicy::kAllow;
  1252. set_factory_client_security_state(std::move(client_security_state));
  1253. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1254. }
  1255. TEST_F(URLLoaderTest, NonSecureUnknownToLocalPreflightWarn) {
  1256. auto client_security_state = NewSecurityState();
  1257. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1258. client_security_state->private_network_request_policy =
  1259. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1260. set_factory_client_security_state(std::move(client_security_state));
  1261. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1262. IsError(net::ERR_FAILED));
  1263. EXPECT_THAT(
  1264. client()->completion_status().cors_error_status,
  1265. Optional(CorsErrorStatus(
  1266. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1267. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1268. }
  1269. TEST_F(URLLoaderTest, NonSecureUnknownToLocalPreflightBlock) {
  1270. auto client_security_state = NewSecurityState();
  1271. client_security_state->ip_address_space = mojom::IPAddressSpace::kUnknown;
  1272. client_security_state->private_network_request_policy =
  1273. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1274. set_factory_client_security_state(std::move(client_security_state));
  1275. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1276. IsError(net::ERR_FAILED));
  1277. EXPECT_THAT(
  1278. client()->completion_status().cors_error_status,
  1279. Optional(CorsErrorStatus(
  1280. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1281. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1282. }
  1283. TEST_F(URLLoaderTest, SecurePublicToLocalBlock) {
  1284. auto client_security_state = NewSecurityState();
  1285. client_security_state->is_web_secure_context = true;
  1286. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1287. set_factory_client_security_state(std::move(client_security_state));
  1288. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1289. IsError(net::ERR_FAILED));
  1290. EXPECT_THAT(client()->completion_status().cors_error_status,
  1291. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1292. mojom::IPAddressSpace::kLocal)));
  1293. }
  1294. TEST_F(URLLoaderTest, SecurePublicToLocalWarn) {
  1295. auto client_security_state = NewSecurityState();
  1296. client_security_state->is_web_secure_context = true;
  1297. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1298. client_security_state->private_network_request_policy =
  1299. mojom::PrivateNetworkRequestPolicy::kWarn;
  1300. set_factory_client_security_state(std::move(client_security_state));
  1301. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1302. }
  1303. TEST_F(URLLoaderTest, SecurePublicToLocalAllow) {
  1304. auto client_security_state = NewSecurityState();
  1305. client_security_state->is_web_secure_context = true;
  1306. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1307. client_security_state->private_network_request_policy =
  1308. mojom::PrivateNetworkRequestPolicy::kAllow;
  1309. set_factory_client_security_state(std::move(client_security_state));
  1310. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1311. }
  1312. TEST_F(URLLoaderTest, SecurePublicToLocalPreflightWarn) {
  1313. auto client_security_state = NewSecurityState();
  1314. client_security_state->is_web_secure_context = true;
  1315. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1316. client_security_state->private_network_request_policy =
  1317. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1318. set_factory_client_security_state(std::move(client_security_state));
  1319. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1320. IsError(net::ERR_FAILED));
  1321. EXPECT_THAT(
  1322. client()->completion_status().cors_error_status,
  1323. Optional(CorsErrorStatus(
  1324. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1325. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1326. }
  1327. TEST_F(URLLoaderTest, SecurePublicToLocalPreflightBlock) {
  1328. auto client_security_state = NewSecurityState();
  1329. client_security_state->is_web_secure_context = true;
  1330. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1331. client_security_state->private_network_request_policy =
  1332. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1333. set_factory_client_security_state(std::move(client_security_state));
  1334. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1335. IsError(net::ERR_FAILED));
  1336. EXPECT_THAT(
  1337. client()->completion_status().cors_error_status,
  1338. Optional(CorsErrorStatus(
  1339. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1340. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1341. }
  1342. TEST_F(URLLoaderTest, NonSecurePublicToLocalBlock) {
  1343. auto client_security_state = NewSecurityState();
  1344. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1345. set_factory_client_security_state(std::move(client_security_state));
  1346. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1347. IsError(net::ERR_FAILED));
  1348. EXPECT_THAT(client()->completion_status().cors_error_status,
  1349. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1350. mojom::IPAddressSpace::kLocal)));
  1351. }
  1352. TEST_F(URLLoaderTest, NonSecurePublicToLocalWarn) {
  1353. auto client_security_state = NewSecurityState();
  1354. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1355. client_security_state->private_network_request_policy =
  1356. mojom::PrivateNetworkRequestPolicy::kWarn;
  1357. set_factory_client_security_state(std::move(client_security_state));
  1358. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1359. }
  1360. TEST_F(URLLoaderTest, NonSecurePublicToLocalAllow) {
  1361. auto client_security_state = NewSecurityState();
  1362. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1363. client_security_state->private_network_request_policy =
  1364. mojom::PrivateNetworkRequestPolicy::kAllow;
  1365. set_factory_client_security_state(std::move(client_security_state));
  1366. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1367. }
  1368. TEST_F(URLLoaderTest, NonSecurePublicToLocalPreflightWarn) {
  1369. auto client_security_state = NewSecurityState();
  1370. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1371. client_security_state->private_network_request_policy =
  1372. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1373. set_factory_client_security_state(std::move(client_security_state));
  1374. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1375. IsError(net::ERR_FAILED));
  1376. EXPECT_THAT(
  1377. client()->completion_status().cors_error_status,
  1378. Optional(CorsErrorStatus(
  1379. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1380. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1381. }
  1382. TEST_F(URLLoaderTest, NonSecurePublicToLocalPreflightBlock) {
  1383. auto client_security_state = NewSecurityState();
  1384. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1385. client_security_state->private_network_request_policy =
  1386. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1387. set_factory_client_security_state(std::move(client_security_state));
  1388. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1389. IsError(net::ERR_FAILED));
  1390. EXPECT_THAT(
  1391. client()->completion_status().cors_error_status,
  1392. Optional(CorsErrorStatus(
  1393. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1394. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1395. }
  1396. TEST_F(URLLoaderTest, SecurePrivateToLocalBlock) {
  1397. auto client_security_state = NewSecurityState();
  1398. client_security_state->is_web_secure_context = true;
  1399. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1400. set_factory_client_security_state(std::move(client_security_state));
  1401. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1402. IsError(net::ERR_FAILED));
  1403. EXPECT_THAT(client()->completion_status().cors_error_status,
  1404. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1405. mojom::IPAddressSpace::kLocal)));
  1406. }
  1407. TEST_F(URLLoaderTest, SecurePrivateToLocalWarn) {
  1408. auto client_security_state = NewSecurityState();
  1409. client_security_state->is_web_secure_context = true;
  1410. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1411. client_security_state->private_network_request_policy =
  1412. mojom::PrivateNetworkRequestPolicy::kWarn;
  1413. set_factory_client_security_state(std::move(client_security_state));
  1414. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1415. }
  1416. TEST_F(URLLoaderTest, SecurePrivateToLocalAllow) {
  1417. auto client_security_state = NewSecurityState();
  1418. client_security_state->is_web_secure_context = true;
  1419. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1420. client_security_state->private_network_request_policy =
  1421. mojom::PrivateNetworkRequestPolicy::kAllow;
  1422. set_factory_client_security_state(std::move(client_security_state));
  1423. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1424. }
  1425. TEST_F(URLLoaderTest, SecurePrivateToLocalPreflightBlock) {
  1426. auto client_security_state = NewSecurityState();
  1427. client_security_state->is_web_secure_context = true;
  1428. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1429. client_security_state->private_network_request_policy =
  1430. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1431. set_factory_client_security_state(std::move(client_security_state));
  1432. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1433. IsError(net::ERR_FAILED));
  1434. EXPECT_THAT(
  1435. client()->completion_status().cors_error_status,
  1436. Optional(CorsErrorStatus(
  1437. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1438. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1439. }
  1440. TEST_F(URLLoaderTest, SecurePrivateToLocalPreflightWarn) {
  1441. auto client_security_state = NewSecurityState();
  1442. client_security_state->is_web_secure_context = true;
  1443. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1444. client_security_state->private_network_request_policy =
  1445. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1446. set_factory_client_security_state(std::move(client_security_state));
  1447. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1448. IsError(net::ERR_FAILED));
  1449. EXPECT_THAT(
  1450. client()->completion_status().cors_error_status,
  1451. Optional(CorsErrorStatus(
  1452. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1453. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1454. }
  1455. TEST_F(URLLoaderTest, NonSecurePrivateToLocalBlock) {
  1456. auto client_security_state = NewSecurityState();
  1457. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1458. set_factory_client_security_state(std::move(client_security_state));
  1459. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1460. IsError(net::ERR_FAILED));
  1461. EXPECT_THAT(client()->completion_status().cors_error_status,
  1462. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1463. mojom::IPAddressSpace::kLocal)));
  1464. }
  1465. TEST_F(URLLoaderTest, NonSecurePrivateToLocalWarn) {
  1466. auto client_security_state = NewSecurityState();
  1467. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1468. client_security_state->private_network_request_policy =
  1469. mojom::PrivateNetworkRequestPolicy::kWarn;
  1470. set_factory_client_security_state(std::move(client_security_state));
  1471. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1472. }
  1473. TEST_F(URLLoaderTest, NonSecurePrivateToLocalAllow) {
  1474. auto client_security_state = NewSecurityState();
  1475. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1476. client_security_state->private_network_request_policy =
  1477. mojom::PrivateNetworkRequestPolicy::kAllow;
  1478. set_factory_client_security_state(std::move(client_security_state));
  1479. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1480. }
  1481. TEST_F(URLLoaderTest, NonSecurePrivateToLocalPreflightBlock) {
  1482. auto client_security_state = NewSecurityState();
  1483. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1484. client_security_state->private_network_request_policy =
  1485. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1486. set_factory_client_security_state(std::move(client_security_state));
  1487. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1488. IsError(net::ERR_FAILED));
  1489. EXPECT_THAT(
  1490. client()->completion_status().cors_error_status,
  1491. Optional(CorsErrorStatus(
  1492. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1493. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1494. }
  1495. TEST_F(URLLoaderTest, NonSecurePrivateToLocalPreflightWarn) {
  1496. auto client_security_state = NewSecurityState();
  1497. client_security_state->ip_address_space = mojom::IPAddressSpace::kPrivate;
  1498. client_security_state->private_network_request_policy =
  1499. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1500. set_factory_client_security_state(std::move(client_security_state));
  1501. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")),
  1502. IsError(net::ERR_FAILED));
  1503. EXPECT_THAT(
  1504. client()->completion_status().cors_error_status,
  1505. Optional(CorsErrorStatus(
  1506. mojom::CorsError::kUnexpectedPrivateNetworkAccess,
  1507. mojom::IPAddressSpace::kUnknown, mojom::IPAddressSpace::kLocal)));
  1508. }
  1509. TEST_F(URLLoaderTest, SecureLocalToLocalBlock) {
  1510. auto client_security_state = NewSecurityState();
  1511. client_security_state->is_web_secure_context = true;
  1512. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1513. set_factory_client_security_state(std::move(client_security_state));
  1514. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1515. }
  1516. TEST_F(URLLoaderTest, SecureLocalToLocalWarn) {
  1517. auto client_security_state = NewSecurityState();
  1518. client_security_state->is_web_secure_context = true;
  1519. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1520. client_security_state->private_network_request_policy =
  1521. mojom::PrivateNetworkRequestPolicy::kWarn;
  1522. set_factory_client_security_state(std::move(client_security_state));
  1523. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1524. }
  1525. TEST_F(URLLoaderTest, SecureLocalToLocalAllow) {
  1526. auto client_security_state = NewSecurityState();
  1527. client_security_state->is_web_secure_context = true;
  1528. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1529. client_security_state->private_network_request_policy =
  1530. mojom::PrivateNetworkRequestPolicy::kAllow;
  1531. set_factory_client_security_state(std::move(client_security_state));
  1532. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1533. }
  1534. TEST_F(URLLoaderTest, SecureLocalToLocalPreflightBlock) {
  1535. auto client_security_state = NewSecurityState();
  1536. client_security_state->is_web_secure_context = true;
  1537. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1538. client_security_state->private_network_request_policy =
  1539. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1540. set_factory_client_security_state(std::move(client_security_state));
  1541. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1542. }
  1543. TEST_F(URLLoaderTest, SecureLocalToLocalPreflightWarn) {
  1544. auto client_security_state = NewSecurityState();
  1545. client_security_state->is_web_secure_context = true;
  1546. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1547. client_security_state->private_network_request_policy =
  1548. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1549. set_factory_client_security_state(std::move(client_security_state));
  1550. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1551. }
  1552. TEST_F(URLLoaderTest, NonSecureLocalToLocalBlock) {
  1553. auto client_security_state = NewSecurityState();
  1554. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1555. set_factory_client_security_state(std::move(client_security_state));
  1556. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1557. }
  1558. TEST_F(URLLoaderTest, NonSecureLocalToLocalWarn) {
  1559. auto client_security_state = NewSecurityState();
  1560. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1561. client_security_state->private_network_request_policy =
  1562. mojom::PrivateNetworkRequestPolicy::kWarn;
  1563. set_factory_client_security_state(std::move(client_security_state));
  1564. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1565. }
  1566. TEST_F(URLLoaderTest, NonSecureLocalToLocalAllow) {
  1567. auto client_security_state = NewSecurityState();
  1568. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1569. client_security_state->private_network_request_policy =
  1570. mojom::PrivateNetworkRequestPolicy::kAllow;
  1571. set_factory_client_security_state(std::move(client_security_state));
  1572. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1573. }
  1574. TEST_F(URLLoaderTest, NonSecureLocalToLocalPreflightBlock) {
  1575. auto client_security_state = NewSecurityState();
  1576. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1577. client_security_state->private_network_request_policy =
  1578. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1579. set_factory_client_security_state(std::move(client_security_state));
  1580. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1581. }
  1582. TEST_F(URLLoaderTest, NonSecureLocalToLocalPreflightWarn) {
  1583. auto client_security_state = NewSecurityState();
  1584. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1585. client_security_state->private_network_request_policy =
  1586. mojom::PrivateNetworkRequestPolicy::kPreflightWarn;
  1587. set_factory_client_security_state(std::move(client_security_state));
  1588. EXPECT_THAT(Load(test_server()->GetURL("/empty.html")), IsOk());
  1589. }
  1590. TEST_F(URLLoaderTest, AddsNetLogEntryForPrivateNetworkAccessCheckSuccess) {
  1591. auto client_security_state = NewSecurityState();
  1592. client_security_state->ip_address_space = mojom::IPAddressSpace::kLocal;
  1593. set_factory_client_security_state(std::move(client_security_state));
  1594. net::RecordingNetLogObserver net_log_observer;
  1595. std::ignore = Load(test_server()->GetURL("/empty.html"));
  1596. std::vector<net::NetLogEntry> entries = net_log_observer.GetEntriesWithType(
  1597. net::NetLogEventType::PRIVATE_NETWORK_ACCESS_CHECK);
  1598. ASSERT_THAT(entries, SizeIs(1));
  1599. const base::Value& params = entries[0].params;
  1600. ASSERT_EQ(params.type(), base::Value::Type::DICTIONARY);
  1601. EXPECT_THAT(params.FindStringKey("client_address_space"),
  1602. Pointee(Eq("local")));
  1603. EXPECT_THAT(params.FindStringKey("resource_address_space"),
  1604. Pointee(Eq("local")));
  1605. EXPECT_THAT(params.FindStringKey("result"),
  1606. Pointee(Eq("allowed-no-less-public")));
  1607. }
  1608. TEST_F(URLLoaderTest, AddsNetLogEntryForPrivateNetworkAccessCheckFailure) {
  1609. auto client_security_state = NewSecurityState();
  1610. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  1611. client_security_state->private_network_request_policy =
  1612. mojom::PrivateNetworkRequestPolicy::kPreflightBlock;
  1613. set_factory_client_security_state(std::move(client_security_state));
  1614. net::RecordingNetLogObserver net_log_observer;
  1615. std::ignore = Load(test_server()->GetURL("/empty.html"));
  1616. std::vector<net::NetLogEntry> entries = net_log_observer.GetEntriesWithType(
  1617. net::NetLogEventType::PRIVATE_NETWORK_ACCESS_CHECK);
  1618. ASSERT_THAT(entries, SizeIs(1));
  1619. const base::Value& params = entries[0].params;
  1620. ASSERT_EQ(params.type(), base::Value::Type::DICTIONARY);
  1621. EXPECT_THAT(params.FindStringKey("client_address_space"),
  1622. Pointee(Eq("public")));
  1623. EXPECT_THAT(params.FindStringKey("resource_address_space"),
  1624. Pointee(Eq("local")));
  1625. EXPECT_THAT(params.FindStringKey("result"),
  1626. Pointee(Eq("blocked-by-policy-preflight-block")));
  1627. }
  1628. // Bundles together the inputs to a parameterized private network request test.
  1629. struct URLLoaderFakeTransportInfoTestParams {
  1630. // The address space of the client.
  1631. mojom::IPAddressSpace client_address_space;
  1632. // The address space of the endpoint serving the request.
  1633. mojom::IPAddressSpace endpoint_address_space;
  1634. // The type of transport to set in `TransportInfo`.
  1635. net::TransportType transport_type;
  1636. // The expected request result.
  1637. int expected_result;
  1638. };
  1639. // For clarity when debugging parameterized test failures.
  1640. std::ostream& operator<<(std::ostream& out,
  1641. const URLLoaderFakeTransportInfoTestParams& params) {
  1642. return out << "{ client_address_space: " << params.client_address_space
  1643. << ", endpoint_address_space: " << params.endpoint_address_space
  1644. << ", transport_type: "
  1645. << net::TransportTypeToString(params.transport_type)
  1646. << ", expected_result: "
  1647. << net::ErrorToString(params.expected_result) << " }";
  1648. }
  1649. mojom::IPAddressSpace ResponseAddressSpace(
  1650. const URLLoaderFakeTransportInfoTestParams& params) {
  1651. switch (params.transport_type) {
  1652. case net::TransportType::kDirect:
  1653. case net::TransportType::kCached:
  1654. return params.endpoint_address_space;
  1655. case net::TransportType::kProxied:
  1656. case net::TransportType::kCachedFromProxy:
  1657. return mojom::IPAddressSpace::kUnknown;
  1658. }
  1659. }
  1660. class URLLoaderFakeTransportInfoTest
  1661. : public URLLoaderTest,
  1662. public testing::WithParamInterface<URLLoaderFakeTransportInfoTestParams> {
  1663. protected:
  1664. // Returns an address in the given IP address space.
  1665. static net::IPAddress FakeAddress(mojom::IPAddressSpace space) {
  1666. switch (space) {
  1667. case mojom::IPAddressSpace::kUnknown:
  1668. return net::IPAddress();
  1669. case mojom::IPAddressSpace::kPublic:
  1670. return net::IPAddress(42, 0, 1, 2);
  1671. case mojom::IPAddressSpace::kPrivate:
  1672. return net::IPAddress(10, 0, 1, 2);
  1673. case mojom::IPAddressSpace::kLocal:
  1674. return net::IPAddress::IPv4Localhost();
  1675. }
  1676. }
  1677. // Returns an endpoint in the given IP address space.
  1678. static net::IPEndPoint FakeEndpoint(mojom::IPAddressSpace space) {
  1679. return net::IPEndPoint(FakeAddress(space), 80);
  1680. }
  1681. // Returns a transport info with an endpoint in the given IP address space.
  1682. static net::TransportInfo FakeTransportInfo(
  1683. const URLLoaderFakeTransportInfoTestParams& params) {
  1684. return net::TransportInfo(params.transport_type,
  1685. FakeEndpoint(params.endpoint_address_space), "");
  1686. }
  1687. };
  1688. // This test verifies that requests made from insecure contexts are handled
  1689. // appropriately when they go from a less-private address space to a
  1690. // more-private address space or not. The test is parameterized by
  1691. // (client address space, server address space, expected result) tuple.
  1692. TEST_P(URLLoaderFakeTransportInfoTest, PrivateNetworkRequestLoadsCorrectly) {
  1693. const auto params = GetParam();
  1694. auto client_security_state = NewSecurityState();
  1695. client_security_state->ip_address_space = params.client_address_space;
  1696. set_factory_client_security_state(std::move(client_security_state));
  1697. const GURL url("http://fake-endpoint");
  1698. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  1699. url, std::make_unique<FakeTransportInfoInterceptor>(
  1700. FakeTransportInfo(params)));
  1701. // Despite its name, IsError(OK) asserts that the matched value is OK.
  1702. EXPECT_THAT(Load(url), IsError(params.expected_result));
  1703. if (params.expected_result != net::OK) {
  1704. if (params.expected_result !=
  1705. net::
  1706. ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_PRIVATE_NETWORK_ACCESS_POLICY) {
  1707. // CORS error status shouldn't be set when the cache entry was blocked by
  1708. // private network access policy because we'll retry fetching from the
  1709. // network.
  1710. EXPECT_THAT(client()->completion_status().cors_error_status,
  1711. Optional(InsecurePrivateNetworkCorsErrorStatus(
  1712. params.endpoint_address_space)));
  1713. }
  1714. return;
  1715. }
  1716. // Check that the right address spaces are reported in `URLResponseHead`.
  1717. ASSERT_FALSE(client()->response_head().is_null());
  1718. EXPECT_EQ(client()->response_head()->client_address_space,
  1719. params.client_address_space);
  1720. EXPECT_EQ(client()->response_head()->response_address_space,
  1721. ResponseAddressSpace(params));
  1722. }
  1723. // Lists all combinations we want to test in URLLoaderFakeTransportInfoTest.
  1724. constexpr URLLoaderFakeTransportInfoTestParams
  1725. kURLLoaderFakeTransportInfoTestParamsList[] = {
  1726. // Client: kUnknown
  1727. {
  1728. mojom::IPAddressSpace::kUnknown,
  1729. mojom::IPAddressSpace::kUnknown,
  1730. net::TransportType::kDirect,
  1731. net::OK,
  1732. },
  1733. {
  1734. mojom::IPAddressSpace::kUnknown,
  1735. mojom::IPAddressSpace::kPublic,
  1736. net::TransportType::kDirect,
  1737. net::OK,
  1738. },
  1739. {
  1740. mojom::IPAddressSpace::kUnknown,
  1741. mojom::IPAddressSpace::kPrivate,
  1742. net::TransportType::kDirect,
  1743. net::ERR_FAILED,
  1744. },
  1745. {
  1746. mojom::IPAddressSpace::kUnknown,
  1747. mojom::IPAddressSpace::kLocal,
  1748. net::TransportType::kDirect,
  1749. net::ERR_FAILED,
  1750. },
  1751. // Client: kPublic
  1752. {
  1753. mojom::IPAddressSpace::kPublic,
  1754. mojom::IPAddressSpace::kUnknown,
  1755. net::TransportType::kDirect,
  1756. net::OK,
  1757. },
  1758. {
  1759. mojom::IPAddressSpace::kPublic,
  1760. mojom::IPAddressSpace::kPublic,
  1761. net::TransportType::kDirect,
  1762. net::OK,
  1763. },
  1764. {
  1765. mojom::IPAddressSpace::kPublic,
  1766. mojom::IPAddressSpace::kPrivate,
  1767. net::TransportType::kDirect,
  1768. net::ERR_FAILED,
  1769. },
  1770. {
  1771. mojom::IPAddressSpace::kPublic,
  1772. mojom::IPAddressSpace::kLocal,
  1773. net::TransportType::kDirect,
  1774. net::ERR_FAILED,
  1775. },
  1776. // Client: kPrivate
  1777. {
  1778. mojom::IPAddressSpace::kPrivate,
  1779. mojom::IPAddressSpace::kUnknown,
  1780. net::TransportType::kDirect,
  1781. net::OK,
  1782. },
  1783. {
  1784. mojom::IPAddressSpace::kPrivate,
  1785. mojom::IPAddressSpace::kPublic,
  1786. net::TransportType::kDirect,
  1787. net::OK,
  1788. },
  1789. {
  1790. mojom::IPAddressSpace::kPrivate,
  1791. mojom::IPAddressSpace::kPrivate,
  1792. net::TransportType::kDirect,
  1793. net::OK,
  1794. },
  1795. {
  1796. mojom::IPAddressSpace::kPrivate,
  1797. mojom::IPAddressSpace::kLocal,
  1798. net::TransportType::kDirect,
  1799. net::ERR_FAILED,
  1800. },
  1801. // Client: kLocal
  1802. {
  1803. mojom::IPAddressSpace::kLocal,
  1804. mojom::IPAddressSpace::kUnknown,
  1805. net::TransportType::kDirect,
  1806. net::OK,
  1807. },
  1808. {
  1809. mojom::IPAddressSpace::kLocal,
  1810. mojom::IPAddressSpace::kPublic,
  1811. net::TransportType::kDirect,
  1812. net::OK,
  1813. },
  1814. {
  1815. mojom::IPAddressSpace::kLocal,
  1816. mojom::IPAddressSpace::kPrivate,
  1817. net::TransportType::kDirect,
  1818. net::OK,
  1819. },
  1820. {
  1821. mojom::IPAddressSpace::kLocal,
  1822. mojom::IPAddressSpace::kLocal,
  1823. net::TransportType::kDirect,
  1824. net::OK,
  1825. },
  1826. // TransportType: kProxied
  1827. {
  1828. mojom::IPAddressSpace::kUnknown,
  1829. mojom::IPAddressSpace::kLocal,
  1830. net::TransportType::kProxied,
  1831. net::OK,
  1832. },
  1833. {
  1834. mojom::IPAddressSpace::kPublic,
  1835. mojom::IPAddressSpace::kLocal,
  1836. net::TransportType::kProxied,
  1837. net::OK,
  1838. },
  1839. {
  1840. mojom::IPAddressSpace::kPublic,
  1841. mojom::IPAddressSpace::kPrivate,
  1842. net::TransportType::kProxied,
  1843. net::OK,
  1844. },
  1845. {
  1846. mojom::IPAddressSpace::kPrivate,
  1847. mojom::IPAddressSpace::kLocal,
  1848. net::TransportType::kProxied,
  1849. net::OK,
  1850. },
  1851. // TransportType: kCachedFromProxy
  1852. {
  1853. mojom::IPAddressSpace::kUnknown,
  1854. mojom::IPAddressSpace::kLocal,
  1855. net::TransportType::kCachedFromProxy,
  1856. net::OK,
  1857. },
  1858. {
  1859. mojom::IPAddressSpace::kPublic,
  1860. mojom::IPAddressSpace::kLocal,
  1861. net::TransportType::kCachedFromProxy,
  1862. net::OK,
  1863. },
  1864. {
  1865. mojom::IPAddressSpace::kPublic,
  1866. mojom::IPAddressSpace::kPrivate,
  1867. net::TransportType::kCachedFromProxy,
  1868. net::OK,
  1869. },
  1870. {
  1871. mojom::IPAddressSpace::kPrivate,
  1872. mojom::IPAddressSpace::kLocal,
  1873. net::TransportType::kCachedFromProxy,
  1874. net::OK,
  1875. },
  1876. // TransportType: kCached. We only test a local target for brevity.
  1877. {
  1878. mojom::IPAddressSpace::kUnknown,
  1879. mojom::IPAddressSpace::kLocal,
  1880. net::TransportType::kCached,
  1881. net::
  1882. ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_PRIVATE_NETWORK_ACCESS_POLICY,
  1883. },
  1884. {
  1885. mojom::IPAddressSpace::kPublic,
  1886. mojom::IPAddressSpace::kLocal,
  1887. net::TransportType::kCached,
  1888. net::
  1889. ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_PRIVATE_NETWORK_ACCESS_POLICY,
  1890. },
  1891. {
  1892. mojom::IPAddressSpace::kPrivate,
  1893. mojom::IPAddressSpace::kLocal,
  1894. net::TransportType::kCached,
  1895. net::
  1896. ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_PRIVATE_NETWORK_ACCESS_POLICY,
  1897. },
  1898. {
  1899. mojom::IPAddressSpace::kLocal,
  1900. mojom::IPAddressSpace::kLocal,
  1901. net::TransportType::kCached,
  1902. net::OK,
  1903. },
  1904. };
  1905. INSTANTIATE_TEST_SUITE_P(Parameterized,
  1906. URLLoaderFakeTransportInfoTest,
  1907. ValuesIn(kURLLoaderFakeTransportInfoTestParamsList));
  1908. // Tests that auth challenge info is present on the response when a request
  1909. // receives an authentication challenge.
  1910. TEST_F(URLLoaderTest, AuthChallengeInfo) {
  1911. GURL url = test_server()->GetURL("/auth-basic");
  1912. EXPECT_EQ(net::OK, Load(url));
  1913. ASSERT_TRUE(client()->response_head()->auth_challenge_info.has_value());
  1914. EXPECT_FALSE(client()->response_head()->auth_challenge_info->is_proxy);
  1915. EXPECT_EQ(url::SchemeHostPort(url),
  1916. client()->response_head()->auth_challenge_info->challenger);
  1917. EXPECT_EQ("basic", client()->response_head()->auth_challenge_info->scheme);
  1918. EXPECT_EQ("testrealm", client()->response_head()->auth_challenge_info->realm);
  1919. EXPECT_EQ("Basic realm=\"testrealm\"",
  1920. client()->response_head()->auth_challenge_info->challenge);
  1921. EXPECT_EQ("/auth-basic",
  1922. client()->response_head()->auth_challenge_info->path);
  1923. }
  1924. // Tests that no auth challenge info is present on the response when a request
  1925. // does not receive an authentication challenge.
  1926. TEST_F(URLLoaderTest, NoAuthChallengeInfo) {
  1927. GURL url = test_server()->GetURL("/");
  1928. EXPECT_EQ(net::OK, Load(url));
  1929. EXPECT_FALSE(client()->response_head()->auth_challenge_info.has_value());
  1930. }
  1931. // Test decoded_body_length / encoded_body_length when they're different.
  1932. TEST_F(URLLoaderTest, GzipTest) {
  1933. std::string body;
  1934. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/gzip-body?Body"), &body));
  1935. EXPECT_EQ("Body", body);
  1936. // Deflating a 4-byte string should result in a longer string - main thing to
  1937. // check here, though, is that the two lengths are of different.
  1938. EXPECT_LT(client()->completion_status().decoded_body_length,
  1939. client()->completion_status().encoded_body_length);
  1940. // Over the wire length should include headers, so should be longer.
  1941. EXPECT_LT(client()->completion_status().encoded_body_length,
  1942. client()->completion_status().encoded_data_length);
  1943. }
  1944. TEST_F(URLLoaderTest, ErrorBeforeHeaders) {
  1945. EXPECT_EQ(net::ERR_EMPTY_RESPONSE,
  1946. Load(test_server()->GetURL("/close-socket"), nullptr));
  1947. EXPECT_FALSE(client()->response_body().is_valid());
  1948. }
  1949. TEST_F(URLLoaderTest, SyncErrorWhileReadingBody) {
  1950. std::string body;
  1951. EXPECT_EQ(net::ERR_FAILED,
  1952. Load(net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
  1953. net::URLRequestFailedJob::READ_SYNC, net::ERR_FAILED),
  1954. &body));
  1955. EXPECT_EQ("", body);
  1956. }
  1957. TEST_F(URLLoaderTest, AsyncErrorWhileReadingBody) {
  1958. std::string body;
  1959. EXPECT_EQ(net::ERR_FAILED,
  1960. Load(net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
  1961. net::URLRequestFailedJob::READ_ASYNC, net::ERR_FAILED),
  1962. &body));
  1963. EXPECT_EQ("", body);
  1964. }
  1965. TEST_F(URLLoaderTest, SyncErrorWhileReadingBodyAfterBytesReceived) {
  1966. const std::string kBody("Foo.");
  1967. std::list<std::string> packets;
  1968. packets.push_back(kBody);
  1969. AddMultipleWritesInterceptor(packets, net::ERR_ACCESS_DENIED,
  1970. false /*async_reads*/);
  1971. std::string body;
  1972. EXPECT_EQ(net::ERR_ACCESS_DENIED,
  1973. Load(MultipleWritesInterceptor::GetURL(), &body));
  1974. EXPECT_EQ(kBody, body);
  1975. }
  1976. TEST_F(URLLoaderTest, AsyncErrorWhileReadingBodyAfterBytesReceived) {
  1977. const std::string kBody("Foo.");
  1978. std::list<std::string> packets;
  1979. packets.push_back(kBody);
  1980. AddMultipleWritesInterceptor(packets, net::ERR_ACCESS_DENIED,
  1981. true /*async_reads*/);
  1982. std::string body;
  1983. EXPECT_EQ(net::ERR_ACCESS_DENIED,
  1984. Load(MultipleWritesInterceptor::GetURL(), &body));
  1985. EXPECT_EQ(kBody, body);
  1986. }
  1987. TEST_F(URLLoaderTest, DoNotSniffUnlessSpecified) {
  1988. EXPECT_EQ(net::OK,
  1989. Load(test_server()->GetURL("/content-sniffer-test0.html")));
  1990. EXPECT_FALSE(did_mime_sniff());
  1991. ASSERT_TRUE(mime_type().empty());
  1992. }
  1993. TEST_F(URLLoaderTest, SniffMimeType) {
  1994. set_sniff();
  1995. EXPECT_EQ(net::OK,
  1996. Load(test_server()->GetURL("/content-sniffer-test0.html")));
  1997. EXPECT_TRUE(did_mime_sniff());
  1998. ASSERT_EQ(std::string("text/html"), mime_type());
  1999. }
  2000. TEST_F(URLLoaderTest, RespectNoSniff) {
  2001. set_sniff();
  2002. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/nosniff-test.html")));
  2003. EXPECT_FALSE(did_mime_sniff());
  2004. ASSERT_EQ(std::string("text/plain"), mime_type());
  2005. }
  2006. TEST_F(URLLoaderTest, SniffTextPlainDoesNotResultInHTML) {
  2007. set_sniff();
  2008. EXPECT_EQ(net::OK,
  2009. Load(test_server()->GetURL("/content-sniffer-test1.html")));
  2010. EXPECT_TRUE(did_mime_sniff());
  2011. ASSERT_EQ(std::string("text/plain"), mime_type());
  2012. }
  2013. TEST_F(URLLoaderTest, DoNotSniffHTMLFromImageGIF) {
  2014. set_sniff();
  2015. EXPECT_EQ(net::OK,
  2016. Load(test_server()->GetURL("/content-sniffer-test2.html")));
  2017. EXPECT_FALSE(did_mime_sniff());
  2018. ASSERT_EQ(std::string("image/gif"), mime_type());
  2019. }
  2020. TEST_F(URLLoaderTest, EmptyHtmlIsTextPlain) {
  2021. set_sniff();
  2022. EXPECT_EQ(net::OK,
  2023. Load(test_server()->GetURL("/content-sniffer-test4.html")));
  2024. EXPECT_TRUE(did_mime_sniff());
  2025. ASSERT_EQ(std::string("text/plain"), mime_type());
  2026. }
  2027. TEST_F(URLLoaderTest, EmptyHtmlIsTextPlainWithAsyncResponse) {
  2028. set_sniff();
  2029. const std::string kBody;
  2030. std::list<std::string> packets;
  2031. packets.push_back(kBody);
  2032. AddMultipleWritesInterceptor(packets, net::OK, true /*async_reads*/);
  2033. std::string body;
  2034. EXPECT_EQ(net::OK, Load(MultipleWritesInterceptor::GetURL(), &body));
  2035. EXPECT_EQ(kBody, body);
  2036. EXPECT_TRUE(did_mime_sniff());
  2037. ASSERT_EQ(std::string("text/plain"), mime_type());
  2038. }
  2039. // Tests the case where the first read doesn't have enough data to figure out
  2040. // the right mime type. The second read would have enough data even though the
  2041. // total bytes is still smaller than net::kMaxBytesToSniff.
  2042. TEST_F(URLLoaderTest, FirstReadNotEnoughToSniff1) {
  2043. set_sniff();
  2044. std::string first(500, 'a');
  2045. std::string second(std::string(100, 'b'));
  2046. second[10] = 0;
  2047. EXPECT_LE(first.size() + second.size(),
  2048. static_cast<uint32_t>(net::kMaxBytesToSniff));
  2049. LoadPacketsAndVerifyContents(first, second);
  2050. EXPECT_TRUE(did_mime_sniff());
  2051. ASSERT_EQ(std::string("application/octet-stream"), mime_type());
  2052. }
  2053. // Like above, except that the total byte count is > kMaxBytesToSniff.
  2054. TEST_F(URLLoaderTest, FirstReadNotEnoughToSniff2) {
  2055. set_sniff();
  2056. std::string first(500, 'a');
  2057. std::string second(std::string(1000, 'b'));
  2058. second[10] = 0;
  2059. EXPECT_GE(first.size() + second.size(),
  2060. static_cast<uint32_t>(net::kMaxBytesToSniff));
  2061. LoadPacketsAndVerifyContents(first, second);
  2062. EXPECT_TRUE(did_mime_sniff());
  2063. ASSERT_EQ(std::string("application/octet-stream"), mime_type());
  2064. }
  2065. // Tests that even if the first and only read is smaller than the minimum number
  2066. // of bytes needed to sniff, the loader works correctly and returns the data.
  2067. TEST_F(URLLoaderTest, LoneReadNotEnoughToSniff) {
  2068. set_sniff();
  2069. std::string first(net::kMaxBytesToSniff - 100, 'a');
  2070. LoadPacketsAndVerifyContents(first, std::string());
  2071. EXPECT_TRUE(did_mime_sniff());
  2072. ASSERT_EQ(std::string("text/plain"), mime_type());
  2073. }
  2074. // Tests the simple case where the first read is enough to sniff.
  2075. TEST_F(URLLoaderTest, FirstReadIsEnoughToSniff) {
  2076. set_sniff();
  2077. std::string first(net::kMaxBytesToSniff + 100, 'a');
  2078. LoadPacketsAndVerifyContents(first, std::string());
  2079. EXPECT_TRUE(did_mime_sniff());
  2080. ASSERT_EQ(std::string("text/plain"), mime_type());
  2081. }
  2082. class NeverFinishedBodyHttpResponse : public net::test_server::HttpResponse {
  2083. public:
  2084. NeverFinishedBodyHttpResponse() = default;
  2085. ~NeverFinishedBodyHttpResponse() override = default;
  2086. private:
  2087. // net::test_server::HttpResponse implementation.
  2088. void SendResponse(
  2089. base::WeakPtr<net::test_server::HttpResponseDelegate> delegate) override {
  2090. delegate->SendResponseHeaders(net::HTTP_OK, "OK",
  2091. {{"Content-Type", "text/plain"}});
  2092. delegate->SendContents(
  2093. "long long ago..." +
  2094. std::string(static_cast<uint64_t>(1024 * 1024), 'a'));
  2095. // Never call |done|, so the other side will never see the completion of the
  2096. // response body.
  2097. }
  2098. };
  2099. // Check that the URLLoader tears itself down when the URLLoader pipe is closed.
  2100. TEST_F(URLLoaderTest, DestroyOnURLLoaderPipeClosed) {
  2101. net::EmbeddedTestServer server;
  2102. server.RegisterRequestHandler(
  2103. base::BindRepeating([](const net::test_server::HttpRequest& request) {
  2104. std::unique_ptr<net::test_server::HttpResponse> response =
  2105. std::make_unique<NeverFinishedBodyHttpResponse>();
  2106. return response;
  2107. }));
  2108. ASSERT_TRUE(server.Start());
  2109. ResourceRequest request =
  2110. CreateResourceRequest("GET", server.GetURL("/hello.html"));
  2111. base::RunLoop delete_run_loop;
  2112. mojo::PendingRemote<mojom::URLLoader> loader;
  2113. std::unique_ptr<URLLoader> url_loader;
  2114. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2115. context().mutable_factory_params().is_corb_enabled = false;
  2116. url_loader = std::make_unique<URLLoader>(
  2117. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2118. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  2119. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  2120. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2121. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2122. mojo::NullRemote() /* cookie_observer */,
  2123. mojo::NullRemote() /* url_loader_network_observer */,
  2124. /*devtools_observer=*/mojo::NullRemote(),
  2125. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2126. /*third_party_cookies_enabled=*/true);
  2127. // Run until the response body pipe arrives, to make sure that a live body
  2128. // pipe does not result in keeping the loader alive when the URLLoader pipe is
  2129. // closed.
  2130. client()->RunUntilResponseBodyArrived();
  2131. EXPECT_TRUE(client()->has_received_response());
  2132. EXPECT_FALSE(client()->has_received_completion());
  2133. loader.reset();
  2134. // Spin the message loop until the delete callback is invoked, and then delete
  2135. // the URLLoader.
  2136. delete_run_loop.Run();
  2137. // client()->RunUntilConnectionError();
  2138. // EXPECT_FALSE(client()->has_received_completion());
  2139. client()->RunUntilComplete();
  2140. EXPECT_EQ(net::ERR_FAILED, client()->completion_status().error_code);
  2141. }
  2142. // Make sure that the URLLoader is destroyed when the data pipe is closed.
  2143. // The pipe may either be closed in
  2144. // URLLoader::OnResponseBodyStreamConsumerClosed() or URLLoader::DidRead(),
  2145. // depending on whether the closed pipe is first noticed when trying to write to
  2146. // it, or when a mojo close notification is received, so if only one path
  2147. // breaks, this test may flakily fail.
  2148. TEST_F(URLLoaderTest, CloseResponseBodyConsumerBeforeProducer) {
  2149. net::EmbeddedTestServer server;
  2150. server.RegisterRequestHandler(
  2151. base::BindRepeating([](const net::test_server::HttpRequest& request) {
  2152. std::unique_ptr<net::test_server::HttpResponse> response =
  2153. std::make_unique<NeverFinishedBodyHttpResponse>();
  2154. return response;
  2155. }));
  2156. ASSERT_TRUE(server.Start());
  2157. ResourceRequest request =
  2158. CreateResourceRequest("GET", server.GetURL("/hello.html"));
  2159. base::RunLoop delete_run_loop;
  2160. mojo::PendingRemote<mojom::URLLoader> loader;
  2161. std::unique_ptr<URLLoader> url_loader;
  2162. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2163. context().mutable_factory_params().is_corb_enabled = false;
  2164. url_loader = std::make_unique<URLLoader>(
  2165. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2166. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  2167. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  2168. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2169. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2170. mojo::NullRemote() /* cookie_observer */,
  2171. mojo::NullRemote() /* url_loader_network_observer */,
  2172. /*devtools_observer=*/mojo::NullRemote(),
  2173. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2174. /*third_party_cookies_enabled=*/true);
  2175. client()->RunUntilResponseBodyArrived();
  2176. EXPECT_TRUE(client()->has_received_response());
  2177. EXPECT_FALSE(client()->has_received_completion());
  2178. // Wait for a little amount of time for the response body pipe to be filled.
  2179. // (Please note that this doesn't guarantee that the pipe is filled to the
  2180. // point that it is not writable anymore.)
  2181. base::RunLoop run_loop;
  2182. base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
  2183. FROM_HERE, run_loop.QuitClosure(), base::Milliseconds(100));
  2184. run_loop.Run();
  2185. auto response_body = client()->response_body_release();
  2186. response_body.reset();
  2187. // Spin the message loop until the delete callback is invoked, and then delete
  2188. // the URLLoader.
  2189. delete_run_loop.Run();
  2190. client()->RunUntilComplete();
  2191. EXPECT_EQ(net::ERR_FAILED, client()->completion_status().error_code);
  2192. }
  2193. TEST_F(URLLoaderTest, PauseReadingBodyFromNetBeforeResponseHeaders) {
  2194. const char* const kPath = "/hello.html";
  2195. const char* const kBodyContents = "This is the data as you requested.";
  2196. base::HistogramBase::Sample output_sample = -1;
  2197. base::RunLoop histogram_run_loop;
  2198. auto histogram_callback = StartMonitorBodyReadFromNetBeforePausedHistogram(
  2199. histogram_run_loop.QuitClosure(), &output_sample);
  2200. net::EmbeddedTestServer server;
  2201. net::test_server::ControllableHttpResponse response_controller(&server,
  2202. kPath);
  2203. ASSERT_TRUE(server.Start());
  2204. ResourceRequest request = CreateResourceRequest("GET", server.GetURL(kPath));
  2205. base::RunLoop delete_run_loop;
  2206. mojo::Remote<mojom::URLLoader> loader;
  2207. std::unique_ptr<URLLoader> url_loader;
  2208. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2209. context().mutable_factory_params().is_corb_enabled = false;
  2210. url_loader = std::make_unique<URLLoader>(
  2211. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2212. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2213. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2214. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  2215. nullptr /* trust_token_helper */,
  2216. mojo::NullRemote() /* cookie_observer */,
  2217. mojo::NullRemote() /* url_loader_network_observer */,
  2218. /*devtools_observer=*/mojo::NullRemote(),
  2219. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2220. /*third_party_cookies_enabled=*/true);
  2221. // Pausing reading response body from network stops future reads from the
  2222. // underlying URLRequest. So no data should be sent using the response body
  2223. // data pipe.
  2224. loader->PauseReadingBodyFromNet();
  2225. // In order to avoid flakiness, make sure PauseReadBodyFromNet() is handled by
  2226. // the loader before the test HTTP server serves the response.
  2227. loader.FlushForTesting();
  2228. response_controller.WaitForRequest();
  2229. response_controller.Send(
  2230. "HTTP/1.1 200 OK\r\n"
  2231. "Content-Type: text/plain\r\n\r\n" +
  2232. std::string(kBodyContents));
  2233. response_controller.Done();
  2234. // We will still receive the response body data pipe, although there won't be
  2235. // any data available until ResumeReadBodyFromNet() is called.
  2236. client()->RunUntilResponseBodyArrived();
  2237. EXPECT_TRUE(client()->has_received_response());
  2238. EXPECT_FALSE(client()->has_received_completion());
  2239. // Wait for a little amount of time so that if the loader mistakenly reads
  2240. // response body from the underlying URLRequest, it is easier to find out.
  2241. base::RunLoop run_loop;
  2242. base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
  2243. FROM_HERE, run_loop.QuitClosure(), base::Milliseconds(100));
  2244. run_loop.Run();
  2245. std::string available_data = ReadAvailableBody();
  2246. EXPECT_TRUE(available_data.empty());
  2247. loader->ResumeReadingBodyFromNet();
  2248. client()->RunUntilComplete();
  2249. available_data = ReadBody();
  2250. EXPECT_EQ(kBodyContents, available_data);
  2251. delete_run_loop.Run();
  2252. client()->Unbind();
  2253. histogram_run_loop.Run();
  2254. EXPECT_EQ(0, output_sample);
  2255. }
  2256. TEST_F(URLLoaderTest, PauseReadingBodyFromNetWhenReadIsPending) {
  2257. const char* const kPath = "/hello.html";
  2258. const char* const kBodyContentsFirstHalf = "This is the first half.";
  2259. const char* const kBodyContentsSecondHalf = "This is the second half.";
  2260. base::HistogramBase::Sample output_sample = -1;
  2261. base::RunLoop histogram_run_loop;
  2262. auto histogram_callback = StartMonitorBodyReadFromNetBeforePausedHistogram(
  2263. histogram_run_loop.QuitClosure(), &output_sample);
  2264. net::EmbeddedTestServer server;
  2265. net::test_server::ControllableHttpResponse response_controller(&server,
  2266. kPath);
  2267. ASSERT_TRUE(server.Start());
  2268. ResourceRequest request = CreateResourceRequest("GET", server.GetURL(kPath));
  2269. base::RunLoop delete_run_loop;
  2270. mojo::Remote<mojom::URLLoader> loader;
  2271. std::unique_ptr<URLLoader> url_loader;
  2272. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2273. context().mutable_factory_params().is_corb_enabled = false;
  2274. url_loader = std::make_unique<URLLoader>(
  2275. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2276. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2277. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2278. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  2279. nullptr /* trust_token_helper */,
  2280. mojo::NullRemote() /* cookie_observer */,
  2281. mojo::NullRemote() /* url_loader_network_observer */,
  2282. /*devtools_observer=*/mojo::NullRemote(),
  2283. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2284. /*third_party_cookies_enabled=*/true);
  2285. response_controller.WaitForRequest();
  2286. response_controller.Send(
  2287. "HTTP/1.1 200 OK\r\n"
  2288. "Content-Type: text/plain\r\n\r\n" +
  2289. std::string(kBodyContentsFirstHalf));
  2290. client()->RunUntilResponseBodyArrived();
  2291. EXPECT_TRUE(client()->has_received_response());
  2292. EXPECT_FALSE(client()->has_received_completion());
  2293. loader->PauseReadingBodyFromNet();
  2294. loader.FlushForTesting();
  2295. response_controller.Send(kBodyContentsSecondHalf);
  2296. response_controller.Done();
  2297. // It is uncertain how much data has been read before reading is actually
  2298. // paused, because if there is a pending read when PauseReadingBodyFromNet()
  2299. // arrives, the pending read won't be cancelled. Therefore, this test only
  2300. // checks that after ResumeReadingBodyFromNet() we should be able to get the
  2301. // whole response body.
  2302. loader->ResumeReadingBodyFromNet();
  2303. client()->RunUntilComplete();
  2304. EXPECT_EQ(std::string(kBodyContentsFirstHalf) +
  2305. std::string(kBodyContentsSecondHalf),
  2306. ReadBody());
  2307. delete_run_loop.Run();
  2308. client()->Unbind();
  2309. histogram_run_loop.Run();
  2310. EXPECT_LE(0, output_sample);
  2311. }
  2312. TEST_F(URLLoaderTest, ResumeReadingBodyFromNetAfterClosingConsumer) {
  2313. const char* const kPath = "/hello.html";
  2314. const char* const kBodyContentsFirstHalf = "This is the first half.";
  2315. base::HistogramBase::Sample output_sample = -1;
  2316. base::RunLoop histogram_run_loop;
  2317. auto histogram_callback = StartMonitorBodyReadFromNetBeforePausedHistogram(
  2318. histogram_run_loop.QuitClosure(), &output_sample);
  2319. net::EmbeddedTestServer server;
  2320. net::test_server::ControllableHttpResponse response_controller(&server,
  2321. kPath);
  2322. ASSERT_TRUE(server.Start());
  2323. ResourceRequest request = CreateResourceRequest("GET", server.GetURL(kPath));
  2324. base::RunLoop delete_run_loop;
  2325. mojo::Remote<mojom::URLLoader> loader;
  2326. std::unique_ptr<URLLoader> url_loader;
  2327. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2328. context().mutable_factory_params().is_corb_enabled = false;
  2329. url_loader = std::make_unique<URLLoader>(
  2330. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2331. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2332. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2333. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  2334. nullptr /* trust_token_helper */,
  2335. mojo::NullRemote() /* cookie_observer */,
  2336. mojo::NullRemote() /* url_loader_network_observer */,
  2337. /*devtools_observer=*/mojo::NullRemote(),
  2338. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2339. /*third_party_cookies_enabled=*/true);
  2340. loader->PauseReadingBodyFromNet();
  2341. loader.FlushForTesting();
  2342. response_controller.WaitForRequest();
  2343. response_controller.Send(
  2344. "HTTP/1.1 200 OK\r\n"
  2345. "Content-Type: text/plain\r\n\r\n" +
  2346. std::string(kBodyContentsFirstHalf));
  2347. client()->RunUntilResponseBodyArrived();
  2348. EXPECT_TRUE(client()->has_received_response());
  2349. EXPECT_FALSE(client()->has_received_completion());
  2350. auto response_body = client()->response_body_release();
  2351. response_body.reset();
  2352. // It shouldn't cause any issue even if a ResumeReadingBodyFromNet() call is
  2353. // made after the response body data pipe is closed.
  2354. loader->ResumeReadingBodyFromNet();
  2355. loader.FlushForTesting();
  2356. loader.reset();
  2357. client()->Unbind();
  2358. delete_run_loop.Run();
  2359. histogram_run_loop.Run();
  2360. EXPECT_EQ(0, output_sample);
  2361. }
  2362. TEST_F(URLLoaderTest, MultiplePauseResumeReadingBodyFromNet) {
  2363. const char* const kPath = "/hello.html";
  2364. const char* const kBodyContentsFirstHalf = "This is the first half.";
  2365. const char* const kBodyContentsSecondHalf = "This is the second half.";
  2366. base::HistogramBase::Sample output_sample = -1;
  2367. base::RunLoop histogram_run_loop;
  2368. auto histogram_callback = StartMonitorBodyReadFromNetBeforePausedHistogram(
  2369. histogram_run_loop.QuitClosure(), &output_sample);
  2370. net::EmbeddedTestServer server;
  2371. net::test_server::ControllableHttpResponse response_controller(&server,
  2372. kPath);
  2373. ASSERT_TRUE(server.Start());
  2374. ResourceRequest request = CreateResourceRequest("GET", server.GetURL(kPath));
  2375. base::RunLoop delete_run_loop;
  2376. mojo::Remote<mojom::URLLoader> loader;
  2377. std::unique_ptr<URLLoader> url_loader;
  2378. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2379. context().mutable_factory_params().is_corb_enabled = false;
  2380. url_loader = std::make_unique<URLLoader>(
  2381. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2382. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2383. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2384. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  2385. nullptr /* trust_token_helper */,
  2386. mojo::NullRemote() /* cookie_observer */,
  2387. mojo::NullRemote() /* url_loader_network_observer */,
  2388. /*devtools_observer=*/mojo::NullRemote(),
  2389. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2390. /*third_party_cookies_enabled=*/true);
  2391. // It is okay to call ResumeReadingBodyFromNet() even if there is no prior
  2392. // PauseReadingBodyFromNet().
  2393. loader->ResumeReadingBodyFromNet();
  2394. loader.FlushForTesting();
  2395. response_controller.WaitForRequest();
  2396. response_controller.Send(
  2397. "HTTP/1.1 200 OK\r\n"
  2398. "Content-Type: text/plain\r\n\r\n" +
  2399. std::string(kBodyContentsFirstHalf));
  2400. loader->PauseReadingBodyFromNet();
  2401. client()->RunUntilResponseBodyArrived();
  2402. EXPECT_TRUE(client()->has_received_response());
  2403. EXPECT_FALSE(client()->has_received_completion());
  2404. loader->PauseReadingBodyFromNet();
  2405. loader->PauseReadingBodyFromNet();
  2406. loader.FlushForTesting();
  2407. response_controller.Send(kBodyContentsSecondHalf);
  2408. response_controller.Done();
  2409. // One ResumeReadingBodyFromNet() call will resume reading even if there are
  2410. // multiple PauseReadingBodyFromNet() calls before it.
  2411. loader->ResumeReadingBodyFromNet();
  2412. delete_run_loop.Run();
  2413. client()->RunUntilComplete();
  2414. EXPECT_EQ(std::string(kBodyContentsFirstHalf) +
  2415. std::string(kBodyContentsSecondHalf),
  2416. ReadBody());
  2417. loader.reset();
  2418. client()->Unbind();
  2419. histogram_run_loop.Run();
  2420. EXPECT_LE(0, output_sample);
  2421. }
  2422. TEST_F(URLLoaderTest, UploadBytes) {
  2423. const std::string kRequestBody = "Request Body";
  2424. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2425. request_body->AppendBytes(kRequestBody.c_str(), kRequestBody.length());
  2426. set_request_body(std::move(request_body));
  2427. std::string response_body;
  2428. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2429. EXPECT_EQ(kRequestBody, response_body);
  2430. }
  2431. TEST_F(URLLoaderTest, UploadFile) {
  2432. allow_file_uploads();
  2433. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2434. std::string expected_body;
  2435. ASSERT_TRUE(base::ReadFileToString(file_path, &expected_body))
  2436. << "File not found: " << file_path.value();
  2437. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2438. request_body->AppendFileRange(
  2439. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2440. set_request_body(std::move(request_body));
  2441. std::string response_body;
  2442. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2443. EXPECT_EQ(expected_body, response_body);
  2444. }
  2445. TEST_F(URLLoaderTest, UploadFileWithRange) {
  2446. allow_file_uploads();
  2447. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2448. std::string expected_body;
  2449. ASSERT_TRUE(base::ReadFileToString(file_path, &expected_body))
  2450. << "File not found: " << file_path.value();
  2451. expected_body = expected_body.substr(1, expected_body.size() - 2);
  2452. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2453. request_body->AppendFileRange(file_path, 1, expected_body.size(),
  2454. base::Time());
  2455. set_request_body(std::move(request_body));
  2456. std::string response_body;
  2457. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2458. EXPECT_EQ(expected_body, response_body);
  2459. }
  2460. TEST_F(URLLoaderTest, UploadTwoFiles) {
  2461. allow_file_uploads();
  2462. base::FilePath file_path1 = GetTestFilePath("simple_page.html");
  2463. base::FilePath file_path2 = GetTestFilePath("hello.html");
  2464. std::string expected_body1;
  2465. std::string expected_body2;
  2466. ASSERT_TRUE(base::ReadFileToString(file_path1, &expected_body1))
  2467. << "File not found: " << file_path1.value();
  2468. ASSERT_TRUE(base::ReadFileToString(file_path2, &expected_body2))
  2469. << "File not found: " << file_path2.value();
  2470. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2471. request_body->AppendFileRange(
  2472. file_path1, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2473. request_body->AppendFileRange(
  2474. file_path2, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2475. set_request_body(std::move(request_body));
  2476. std::string response_body;
  2477. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2478. EXPECT_EQ(expected_body1 + expected_body2, response_body);
  2479. }
  2480. TEST_F(URLLoaderTest, UploadTwoBatchesOfFiles) {
  2481. allow_file_uploads();
  2482. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2483. std::string expected_body;
  2484. size_t num_files = 2 * kMaxFileUploadRequestsPerBatch;
  2485. for (size_t i = 0; i < num_files; ++i) {
  2486. std::string tmp_expected_body;
  2487. ASSERT_TRUE(base::ReadFileToString(file_path, &tmp_expected_body))
  2488. << "File not found: " << file_path.value();
  2489. expected_body += tmp_expected_body;
  2490. }
  2491. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2492. for (size_t i = 0; i < num_files; ++i) {
  2493. request_body->AppendFileRange(
  2494. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2495. }
  2496. set_request_body(std::move(request_body));
  2497. std::string response_body;
  2498. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2499. EXPECT_EQ(expected_body, response_body);
  2500. }
  2501. TEST_F(URLLoaderTest, UploadTwoBatchesOfFilesWithRespondInvalidFile) {
  2502. allow_file_uploads();
  2503. set_upload_files_invalid(true);
  2504. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2505. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2506. size_t num_files = 2 * kMaxFileUploadRequestsPerBatch;
  2507. for (size_t i = 0; i < num_files; ++i) {
  2508. request_body->AppendFileRange(
  2509. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2510. }
  2511. set_request_body(std::move(request_body));
  2512. EXPECT_EQ(net::ERR_ACCESS_DENIED, Load(test_server()->GetURL("/echo")));
  2513. }
  2514. TEST_F(URLLoaderTest, UploadTwoBatchesOfFilesWithRespondDifferentNumOfFiles) {
  2515. allow_file_uploads();
  2516. set_ignore_last_upload_file(true);
  2517. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2518. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2519. size_t num_files = 2 * kMaxFileUploadRequestsPerBatch;
  2520. for (size_t i = 0; i < num_files; ++i) {
  2521. request_body->AppendFileRange(
  2522. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2523. }
  2524. set_request_body(std::move(request_body));
  2525. EXPECT_EQ(net::ERR_FAILED, Load(test_server()->GetURL("/echo")));
  2526. }
  2527. TEST_F(URLLoaderTest, UploadInvalidFile) {
  2528. allow_file_uploads();
  2529. set_upload_files_invalid(true);
  2530. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2531. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2532. request_body->AppendFileRange(
  2533. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2534. set_request_body(std::move(request_body));
  2535. EXPECT_EQ(net::ERR_ACCESS_DENIED, Load(test_server()->GetURL("/echo")));
  2536. }
  2537. TEST_F(URLLoaderTest, UploadFileWithoutNetworkServiceClient) {
  2538. // Don't call allow_file_uploads();
  2539. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2540. scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
  2541. request_body->AppendFileRange(
  2542. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2543. set_request_body(std::move(request_body));
  2544. EXPECT_EQ(net::ERR_ACCESS_DENIED, Load(test_server()->GetURL("/echo")));
  2545. }
  2546. class CallbackSavingNetworkContextClient : public TestNetworkContextClient {
  2547. public:
  2548. void OnFileUploadRequested(int32_t process_id,
  2549. bool async,
  2550. const std::vector<base::FilePath>& file_paths,
  2551. const GURL& destination_url,
  2552. OnFileUploadRequestedCallback callback) override {
  2553. file_upload_requested_callback_ = std::move(callback);
  2554. if (quit_closure_for_on_file_upload_requested_)
  2555. std::move(quit_closure_for_on_file_upload_requested_).Run();
  2556. }
  2557. void RunUntilUploadRequested(OnFileUploadRequestedCallback* callback) {
  2558. if (!file_upload_requested_callback_) {
  2559. base::RunLoop run_loop;
  2560. quit_closure_for_on_file_upload_requested_ = run_loop.QuitClosure();
  2561. run_loop.Run();
  2562. }
  2563. *callback = std::move(file_upload_requested_callback_);
  2564. }
  2565. private:
  2566. base::OnceClosure quit_closure_for_on_file_upload_requested_;
  2567. OnFileUploadRequestedCallback file_upload_requested_callback_;
  2568. };
  2569. TEST_F(URLLoaderTest, UploadFileCanceled) {
  2570. base::FilePath file_path = GetTestFilePath("simple_page.html");
  2571. std::vector<base::File> opened_file;
  2572. opened_file.emplace_back(file_path, base::File::FLAG_OPEN |
  2573. base::File::FLAG_READ |
  2574. base::File::FLAG_ASYNC);
  2575. ASSERT_TRUE(opened_file.back().IsValid());
  2576. ResourceRequest request =
  2577. CreateResourceRequest("POST", test_server()->GetURL("/echo"));
  2578. request.request_body = new ResourceRequestBody();
  2579. request.request_body->AppendFileRange(
  2580. file_path, 0, std::numeric_limits<uint64_t>::max(), base::Time());
  2581. base::RunLoop delete_run_loop;
  2582. mojo::Remote<mojom::URLLoader> loader;
  2583. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2584. context().mutable_factory_params().is_corb_enabled = false;
  2585. auto network_context_client =
  2586. std::make_unique<CallbackSavingNetworkContextClient>();
  2587. context().set_network_context_client(network_context_client.get());
  2588. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  2589. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2590. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2591. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2592. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  2593. nullptr /* trust_token_helper */,
  2594. mojo::NullRemote() /* cookie_observer */,
  2595. mojo::NullRemote() /* url_loader_network_observer */,
  2596. /*devtools_observer=*/mojo::NullRemote(),
  2597. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2598. /*third_party_cookies_enabled=*/true);
  2599. mojom::NetworkContextClient::OnFileUploadRequestedCallback callback;
  2600. network_context_client->RunUntilUploadRequested(&callback);
  2601. // Check we can call the callback from a deleted URLLoader without crashing.
  2602. url_loader.reset();
  2603. base::RunLoop().RunUntilIdle();
  2604. std::move(callback).Run(net::OK, std::move(opened_file));
  2605. base::RunLoop().RunUntilIdle();
  2606. }
  2607. // Tests a request body with a data pipe element.
  2608. TEST_F(URLLoaderTest, UploadDataPipe) {
  2609. const std::string kRequestBody = "Request Body";
  2610. mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter_remote;
  2611. auto data_pipe_getter = std::make_unique<TestDataPipeGetter>(
  2612. kRequestBody, data_pipe_getter_remote.InitWithNewPipeAndPassReceiver());
  2613. auto resource_request_body = base::MakeRefCounted<ResourceRequestBody>();
  2614. resource_request_body->AppendDataPipe(std::move(data_pipe_getter_remote));
  2615. set_request_body(std::move(resource_request_body));
  2616. std::string response_body;
  2617. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2618. EXPECT_EQ(kRequestBody, response_body);
  2619. }
  2620. // Same as above and tests that the body is sent after a 307 redirect.
  2621. TEST_F(URLLoaderTest, UploadDataPipe_Redirect307) {
  2622. const std::string kRequestBody = "Request Body";
  2623. mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter_remote;
  2624. auto data_pipe_getter = std::make_unique<TestDataPipeGetter>(
  2625. kRequestBody, data_pipe_getter_remote.InitWithNewPipeAndPassReceiver());
  2626. auto resource_request_body = base::MakeRefCounted<ResourceRequestBody>();
  2627. resource_request_body->AppendDataPipe(std::move(data_pipe_getter_remote));
  2628. set_request_body(std::move(resource_request_body));
  2629. set_expect_redirect();
  2630. std::string response_body;
  2631. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/redirect307-to-echo"),
  2632. &response_body));
  2633. EXPECT_EQ(kRequestBody, response_body);
  2634. }
  2635. // Tests a large request body, which should result in multiple asynchronous
  2636. // reads.
  2637. TEST_F(URLLoaderTest, UploadDataPipeWithLotsOfData) {
  2638. std::string request_body;
  2639. request_body.reserve(5 * 1024 * 1024);
  2640. // Using a repeating patter with a length that's prime is more likely to spot
  2641. // out of order or repeated chunks of data.
  2642. while (request_body.size() < 5 * 1024 * 1024)
  2643. request_body.append("foppity");
  2644. mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter_remote;
  2645. auto data_pipe_getter = std::make_unique<TestDataPipeGetter>(
  2646. request_body, data_pipe_getter_remote.InitWithNewPipeAndPassReceiver());
  2647. auto resource_request_body = base::MakeRefCounted<ResourceRequestBody>();
  2648. resource_request_body->AppendDataPipe(std::move(data_pipe_getter_remote));
  2649. set_request_body(std::move(resource_request_body));
  2650. std::string response_body;
  2651. EXPECT_EQ(net::OK, Load(test_server()->GetURL("/echo"), &response_body));
  2652. EXPECT_EQ(request_body, response_body);
  2653. }
  2654. TEST_F(URLLoaderTest, UploadDataPipeError) {
  2655. const std::string kRequestBody = "Request Body";
  2656. mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter_remote;
  2657. auto data_pipe_getter = std::make_unique<TestDataPipeGetter>(
  2658. kRequestBody, data_pipe_getter_remote.InitWithNewPipeAndPassReceiver());
  2659. data_pipe_getter->set_start_error(net::ERR_ACCESS_DENIED);
  2660. auto resource_request_body = base::MakeRefCounted<ResourceRequestBody>();
  2661. resource_request_body->AppendDataPipe(std::move(data_pipe_getter_remote));
  2662. set_request_body(std::move(resource_request_body));
  2663. EXPECT_EQ(net::ERR_ACCESS_DENIED, Load(test_server()->GetURL("/echo")));
  2664. }
  2665. TEST_F(URLLoaderTest, UploadDataPipeClosedEarly) {
  2666. const std::string kRequestBody = "Request Body";
  2667. mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter_remote;
  2668. auto data_pipe_getter = std::make_unique<TestDataPipeGetter>(
  2669. kRequestBody, data_pipe_getter_remote.InitWithNewPipeAndPassReceiver());
  2670. data_pipe_getter->set_pipe_closed_early(true);
  2671. auto resource_request_body = base::MakeRefCounted<ResourceRequestBody>();
  2672. resource_request_body->AppendDataPipe(std::move(data_pipe_getter_remote));
  2673. set_request_body(std::move(resource_request_body));
  2674. std::string response_body;
  2675. EXPECT_EQ(net::ERR_FAILED, Load(test_server()->GetURL("/echo")));
  2676. }
  2677. // Tests a request body with a chunked data pipe element.
  2678. TEST_F(URLLoaderTest, UploadChunkedDataPipe) {
  2679. const std::string kRequestBody = "Request Body";
  2680. TestChunkedDataPipeGetter data_pipe_getter;
  2681. ResourceRequest request =
  2682. CreateResourceRequest("POST", test_server()->GetURL("/echo"));
  2683. request.request_body = base::MakeRefCounted<ResourceRequestBody>();
  2684. request.request_body->SetToChunkedDataPipe(
  2685. data_pipe_getter.GetDataPipeGetterRemote(),
  2686. ResourceRequestBody::ReadOnlyOnce(false));
  2687. base::RunLoop delete_run_loop;
  2688. mojo::Remote<mojom::URLLoader> loader;
  2689. std::unique_ptr<URLLoader> url_loader;
  2690. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2691. context().mutable_factory_params().is_corb_enabled = false;
  2692. url_loader = std::make_unique<URLLoader>(
  2693. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2694. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2695. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2696. 0 /* request_id */, 0 /* keepalive_request_size */,
  2697. nullptr /* keepalive_statistics_reporter */,
  2698. nullptr /* trust_token_helper */,
  2699. mojo::NullRemote() /* cookie_observer */,
  2700. mojo::NullRemote() /* url_loader_network_observer */,
  2701. /*devtools_observer=*/mojo::NullRemote(),
  2702. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2703. /*third_party_cookies_enabled=*/true);
  2704. mojom::ChunkedDataPipeGetter::GetSizeCallback get_size_callback =
  2705. data_pipe_getter.WaitForGetSize();
  2706. mojo::BlockingCopyFromString(kRequestBody,
  2707. data_pipe_getter.WaitForStartReading());
  2708. std::move(get_size_callback).Run(net::OK, kRequestBody.size());
  2709. delete_run_loop.Run();
  2710. client()->RunUntilComplete();
  2711. EXPECT_EQ(kRequestBody, ReadBody());
  2712. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  2713. }
  2714. // Tests a request body with ReadOnceStream.
  2715. TEST_F(URLLoaderTest, UploadReadOnceStream) {
  2716. const std::string kRequestBody = "Request Body";
  2717. TestChunkedDataPipeGetter data_pipe_getter;
  2718. ResourceRequest request =
  2719. CreateResourceRequest("POST", test_server()->GetURL("/echo"));
  2720. request.request_body = base::MakeRefCounted<ResourceRequestBody>();
  2721. request.request_body->SetToChunkedDataPipe(
  2722. data_pipe_getter.GetDataPipeGetterRemote(),
  2723. ResourceRequestBody::ReadOnlyOnce(true));
  2724. base::RunLoop delete_run_loop;
  2725. mojo::Remote<mojom::URLLoader> loader;
  2726. std::unique_ptr<URLLoader> url_loader;
  2727. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2728. context().mutable_factory_params().is_corb_enabled = false;
  2729. url_loader = std::make_unique<URLLoader>(
  2730. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2731. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  2732. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  2733. 0 /* request_id */, 0 /* keepalive_request_size */,
  2734. nullptr /* keepalive_statistics_reporter */,
  2735. nullptr /* trust_token_helper */,
  2736. mojo::NullRemote() /* cookie_observer */,
  2737. mojo::NullRemote() /* url_loader_network_observer */,
  2738. /*devtools_observer=*/mojo::NullRemote(),
  2739. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2740. /*third_party_cookies_enabled=*/true);
  2741. mojom::ChunkedDataPipeGetter::GetSizeCallback get_size_callback =
  2742. data_pipe_getter.WaitForGetSize();
  2743. mojo::BlockingCopyFromString(kRequestBody,
  2744. data_pipe_getter.WaitForStartReading());
  2745. std::move(get_size_callback).Run(net::OK, kRequestBody.size());
  2746. delete_run_loop.Run();
  2747. client()->RunUntilComplete();
  2748. EXPECT_EQ(kRequestBody, ReadBody());
  2749. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  2750. }
  2751. // Tests that SSLInfo is not attached to OnComplete messages or the
  2752. // URLResponseHead when there is no certificate error.
  2753. TEST_F(URLLoaderTest, NoSSLInfoWithoutCertificateError) {
  2754. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2755. ASSERT_TRUE(https_server.Start());
  2756. set_send_ssl_for_cert_error();
  2757. EXPECT_EQ(net::OK, Load(https_server.GetURL("/")));
  2758. EXPECT_FALSE(client()->completion_status().ssl_info.has_value());
  2759. EXPECT_FALSE(client()->response_head()->ssl_info.has_value());
  2760. }
  2761. // Tests that SSLInfo is not attached to OnComplete messages when the
  2762. // corresponding option is not set.
  2763. TEST_F(URLLoaderTest, NoSSLInfoOnComplete) {
  2764. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2765. https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
  2766. ASSERT_TRUE(https_server.Start());
  2767. EXPECT_EQ(net::ERR_INSECURE_RESPONSE, Load(https_server.GetURL("/")));
  2768. EXPECT_FALSE(client()->completion_status().ssl_info.has_value());
  2769. }
  2770. // Tests that SSLInfo is attached to OnComplete messages when the corresponding
  2771. // option is set and the certificate error causes the load to fail.
  2772. TEST_F(URLLoaderTest, SSLInfoOnComplete) {
  2773. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2774. https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
  2775. ASSERT_TRUE(https_server.Start());
  2776. set_send_ssl_for_cert_error();
  2777. EXPECT_EQ(net::ERR_INSECURE_RESPONSE, Load(https_server.GetURL("/")));
  2778. ASSERT_TRUE(client()->completion_status().ssl_info.has_value());
  2779. EXPECT_TRUE(client()->completion_status().ssl_info.value().cert);
  2780. EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
  2781. client()->completion_status().ssl_info.value().cert_status);
  2782. }
  2783. // Tests that SSLInfo is attached to OnComplete messages and the URLResponseHead
  2784. // when the corresponding option is set and the certificate error doesn't cause
  2785. // the load to fail.
  2786. TEST_F(URLLoaderTest, SSLInfoOnResponseWithCertificateError) {
  2787. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2788. https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
  2789. ASSERT_TRUE(https_server.Start());
  2790. set_send_ssl_for_cert_error();
  2791. set_ignore_certificate_errors();
  2792. EXPECT_EQ(net::OK, Load(https_server.GetURL("/")));
  2793. ASSERT_TRUE(client()->completion_status().ssl_info.has_value());
  2794. EXPECT_TRUE(client()->completion_status().ssl_info.value().cert);
  2795. EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
  2796. client()->completion_status().ssl_info.value().cert_status);
  2797. ASSERT_TRUE(client()->response_head()->ssl_info.has_value());
  2798. EXPECT_TRUE(client()->response_head()->ssl_info.value().cert);
  2799. EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
  2800. client()->response_head()->ssl_info.value().cert_status);
  2801. }
  2802. // Tests that SSLInfo is attached to the URLResponseHead on redirects when the
  2803. // corresponding option is set and the certificate error doesn't cause the load
  2804. // to fail.
  2805. TEST_F(URLLoaderTest, SSLInfoOnRedirectWithCertificateError) {
  2806. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
  2807. https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
  2808. https_server.AddDefaultHandlers(
  2809. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  2810. ASSERT_TRUE(https_server.Start());
  2811. TestURLLoaderClient client;
  2812. ResourceRequest request = CreateResourceRequest(
  2813. "GET", https_server.GetURL("/server-redirect?http://foo.test"));
  2814. base::RunLoop delete_run_loop;
  2815. mojo::Remote<mojom::URLLoader> loader;
  2816. std::unique_ptr<URLLoader> url_loader;
  2817. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2818. context().mutable_factory_params().is_corb_enabled = false;
  2819. auto network_context_client = std::make_unique<TestNetworkContextClient>();
  2820. context().set_network_context_client(network_context_client.get());
  2821. TestURLLoaderNetworkObserver url_loader_network_observer;
  2822. url_loader_network_observer.set_ignore_certificate_errors(true);
  2823. url_loader = std::make_unique<URLLoader>(
  2824. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2825. loader.BindNewPipeAndPassReceiver(),
  2826. mojom::kURLLoadOptionSendSSLInfoWithResponse |
  2827. mojom::kURLLoadOptionSendSSLInfoForCertificateError,
  2828. request, client.CreateRemote(), nullptr /* sync_url_loader_client */,
  2829. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2830. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2831. mojo::NullRemote() /* cookie_observer */,
  2832. url_loader_network_observer.Bind() /* url_loader_network_observer */,
  2833. /*devtools_observer=*/mojo::NullRemote(),
  2834. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2835. /*third_party_cookies_enabled=*/true);
  2836. client.RunUntilRedirectReceived();
  2837. ASSERT_TRUE(client.response_head()->ssl_info.has_value());
  2838. EXPECT_TRUE(client.response_head()->ssl_info.value().cert);
  2839. EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
  2840. client.response_head()->ssl_info.value().cert_status);
  2841. }
  2842. // Make sure the client can modify headers during a redirect.
  2843. TEST_F(URLLoaderTest, RedirectModifiedHeaders) {
  2844. ResourceRequest request = CreateResourceRequest(
  2845. "GET", test_server()->GetURL("/redirect307-to-echo"));
  2846. request.headers.SetHeader("Header1", "Value1");
  2847. request.headers.SetHeader("Header2", "Value2");
  2848. base::RunLoop delete_run_loop;
  2849. mojo::Remote<mojom::URLLoader> loader;
  2850. std::unique_ptr<URLLoader> url_loader;
  2851. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2852. context().mutable_factory_params().is_corb_enabled = false;
  2853. url_loader = std::make_unique<URLLoader>(
  2854. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2855. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  2856. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  2857. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2858. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2859. mojo::NullRemote() /* cookie_observer */,
  2860. mojo::NullRemote() /* url_loader_network_observer */,
  2861. /*devtools_observer=*/mojo::NullRemote(),
  2862. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2863. /*third_party_cookies_enabled=*/true);
  2864. client()->RunUntilRedirectReceived();
  2865. // Initial request should only have initial headers.
  2866. const auto& request_headers1 = sent_request().headers;
  2867. EXPECT_EQ("Value1", request_headers1.find("Header1")->second);
  2868. EXPECT_EQ("Value2", request_headers1.find("Header2")->second);
  2869. EXPECT_EQ(request_headers1.end(), request_headers1.find("Header3"));
  2870. // Overwrite Header2 and add Header3.
  2871. net::HttpRequestHeaders redirect_headers;
  2872. redirect_headers.SetHeader("Header2", "");
  2873. redirect_headers.SetHeader("Header3", "Value3");
  2874. loader->FollowRedirect({}, redirect_headers, {}, absl::nullopt);
  2875. client()->RunUntilComplete();
  2876. delete_run_loop.Run();
  2877. // Redirected request should also have modified headers.
  2878. const auto& request_headers2 = sent_request().headers;
  2879. EXPECT_EQ("Value1", request_headers2.find("Header1")->second);
  2880. EXPECT_EQ("", request_headers2.find("Header2")->second);
  2881. EXPECT_EQ("Value3", request_headers2.find("Header3")->second);
  2882. }
  2883. TEST_F(URLLoaderTest, RedirectFailsOnModifyUnsafeHeader) {
  2884. const char* kUnsafeHeaders[] = {
  2885. net::HttpRequestHeaders::kContentLength,
  2886. net::HttpRequestHeaders::kHost,
  2887. net::HttpRequestHeaders::kProxyConnection,
  2888. net::HttpRequestHeaders::kProxyAuthorization,
  2889. "Proxy-Foo",
  2890. };
  2891. for (const auto* unsafe_header : kUnsafeHeaders) {
  2892. TestURLLoaderClient client;
  2893. ResourceRequest request = CreateResourceRequest(
  2894. "GET", test_server()->GetURL("/redirect307-to-echo"));
  2895. base::RunLoop delete_run_loop;
  2896. mojo::Remote<mojom::URLLoader> loader;
  2897. std::unique_ptr<URLLoader> url_loader;
  2898. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2899. context().mutable_factory_params().is_corb_enabled = false;
  2900. url_loader = std::make_unique<URLLoader>(
  2901. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2902. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  2903. client.CreateRemote(), nullptr /* sync_url_loader_client */,
  2904. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2905. 0 /* keepalive_request_size */, nullptr,
  2906. nullptr /* trust_token_helper */,
  2907. mojo::NullRemote() /* cookie_observer */,
  2908. mojo::NullRemote() /* url_loader_network_observer */,
  2909. /*devtools_observer=*/mojo::NullRemote(),
  2910. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2911. /*third_party_cookies_enabled=*/true);
  2912. client.RunUntilRedirectReceived();
  2913. net::HttpRequestHeaders redirect_headers;
  2914. redirect_headers.SetHeader(unsafe_header, "foo");
  2915. loader->FollowRedirect({}, redirect_headers, {}, absl::nullopt);
  2916. client.RunUntilComplete();
  2917. delete_run_loop.Run();
  2918. EXPECT_TRUE(client.has_received_completion());
  2919. EXPECT_EQ(net::ERR_INVALID_ARGUMENT, client.completion_status().error_code);
  2920. }
  2921. }
  2922. TEST_F(URLLoaderTest, RedirectLogsModifiedConcerningHeader) {
  2923. using ConcerningHeaderId = URLLoader::ConcerningHeaderId;
  2924. base::HistogramTester histograms;
  2925. TestURLLoaderClient client;
  2926. ResourceRequest request = CreateResourceRequest(
  2927. "GET", test_server()->GetURL("/redirect307-to-echo"));
  2928. base::RunLoop delete_run_loop;
  2929. mojo::Remote<mojom::URLLoader> loader;
  2930. std::unique_ptr<URLLoader> url_loader;
  2931. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2932. context().mutable_factory_params().is_corb_enabled = false;
  2933. url_loader = std::make_unique<URLLoader>(
  2934. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2935. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  2936. client.CreateRemote(), nullptr /* sync_url_loader_client */,
  2937. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2938. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2939. mojo::NullRemote() /* cookie_observer */,
  2940. mojo::NullRemote() /* url_loader_network_observer */,
  2941. /*devtools_observer=*/mojo::NullRemote(),
  2942. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2943. /*third_party_cookies_enabled=*/true);
  2944. client.RunUntilRedirectReceived();
  2945. net::HttpRequestHeaders redirect_headers;
  2946. redirect_headers.SetHeader(net::HttpRequestHeaders::kReferer,
  2947. "https://somewhere.test/");
  2948. redirect_headers.SetHeader("Via", "Albuquerque");
  2949. loader->FollowRedirect({}, redirect_headers, {}, absl::nullopt);
  2950. client.RunUntilComplete();
  2951. delete_run_loop.Run();
  2952. EXPECT_TRUE(client.has_received_completion());
  2953. EXPECT_EQ(net::OK, client.completion_status().error_code);
  2954. histograms.ExpectBucketCount(
  2955. "NetworkService.ConcerningRequestHeader.AddedOnRedirect", true, 1);
  2956. histograms.ExpectBucketCount(
  2957. "NetworkService.ConcerningRequestHeader.AddedOnRedirect", false, 0);
  2958. for (int i = 0; i < static_cast<int>(ConcerningHeaderId::kMaxValue); ++i) {
  2959. if (i == static_cast<int>(ConcerningHeaderId::kReferer) ||
  2960. i == static_cast<int>(ConcerningHeaderId::kVia)) {
  2961. histograms.ExpectBucketCount(
  2962. "NetworkService.ConcerningRequestHeader.HeaderAddedOnRedirect", i, 1);
  2963. } else {
  2964. histograms.ExpectBucketCount(
  2965. "NetworkService.ConcerningRequestHeader.HeaderAddedOnRedirect", i, 0);
  2966. }
  2967. }
  2968. }
  2969. // Test the client can remove headers during a redirect.
  2970. TEST_F(URLLoaderTest, RedirectRemoveHeader) {
  2971. ResourceRequest request = CreateResourceRequest(
  2972. "GET", test_server()->GetURL("/redirect307-to-echo"));
  2973. request.headers.SetHeader("Header1", "Value1");
  2974. request.headers.SetHeader("Header2", "Value2");
  2975. base::RunLoop delete_run_loop;
  2976. mojo::Remote<mojom::URLLoader> loader;
  2977. std::unique_ptr<URLLoader> url_loader;
  2978. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  2979. context().mutable_factory_params().is_corb_enabled = false;
  2980. url_loader = std::make_unique<URLLoader>(
  2981. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  2982. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  2983. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  2984. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  2985. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  2986. mojo::NullRemote() /* cookie_observer */,
  2987. mojo::NullRemote() /* url_loader_network_observer */,
  2988. /*devtools_observer=*/mojo::NullRemote(),
  2989. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  2990. /*third_party_cookies_enabled=*/true);
  2991. client()->RunUntilRedirectReceived();
  2992. // Initial request should only have initial headers.
  2993. const auto& request_headers1 = sent_request().headers;
  2994. EXPECT_EQ("Value1", request_headers1.find("Header1")->second);
  2995. EXPECT_EQ("Value2", request_headers1.find("Header2")->second);
  2996. // Remove Header1.
  2997. std::vector<std::string> removed_headers = {"Header1"};
  2998. loader->FollowRedirect(removed_headers, {}, {}, absl::nullopt);
  2999. client()->RunUntilComplete();
  3000. delete_run_loop.Run();
  3001. // Redirected request should have the updated headers.
  3002. const auto& request_headers2 = sent_request().headers;
  3003. EXPECT_EQ(request_headers2.end(), request_headers2.find("Header1"));
  3004. EXPECT_EQ("Value2", request_headers2.find("Header2")->second);
  3005. }
  3006. // Test the client can remove headers and add headers back during a redirect.
  3007. TEST_F(URLLoaderTest, RedirectRemoveHeaderAndAddItBack) {
  3008. ResourceRequest request = CreateResourceRequest(
  3009. "GET", test_server()->GetURL("/redirect307-to-echo"));
  3010. request.headers.SetHeader("Header1", "Value1");
  3011. request.headers.SetHeader("Header2", "Value2");
  3012. base::RunLoop delete_run_loop;
  3013. mojo::Remote<mojom::URLLoader> loader;
  3014. std::unique_ptr<URLLoader> url_loader;
  3015. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3016. context().mutable_factory_params().is_corb_enabled = false;
  3017. url_loader = std::make_unique<URLLoader>(
  3018. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3019. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  3020. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3021. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3022. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3023. mojo::NullRemote() /* cookie_observer */,
  3024. mojo::NullRemote() /* url_loader_network_observer */,
  3025. /*devtools_observer=*/mojo::NullRemote(),
  3026. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3027. /*third_party_cookies_enabled=*/true);
  3028. client()->RunUntilRedirectReceived();
  3029. // Initial request should only have initial headers.
  3030. const auto& request_headers1 = sent_request().headers;
  3031. EXPECT_EQ("Value1", request_headers1.find("Header1")->second);
  3032. EXPECT_EQ("Value2", request_headers1.find("Header2")->second);
  3033. // Remove Header1 and add it back using a different value.
  3034. std::vector<std::string> removed_headers = {"Header1"};
  3035. net::HttpRequestHeaders modified_headers;
  3036. modified_headers.SetHeader("Header1", "NewValue1");
  3037. loader->FollowRedirect(removed_headers, modified_headers, {}, absl::nullopt);
  3038. client()->RunUntilComplete();
  3039. delete_run_loop.Run();
  3040. // Redirected request should have the updated headers.
  3041. const auto& request_headers2 = sent_request().headers;
  3042. EXPECT_EQ("NewValue1", request_headers2.find("Header1")->second);
  3043. EXPECT_EQ("Value2", request_headers2.find("Header2")->second);
  3044. }
  3045. // Validate Sec- prefixed headers are handled properly when redirecting from
  3046. // insecure => secure urls. The Sec-Fetch-Site header should be re-added on the
  3047. // secure url.
  3048. TEST_F(URLLoaderTest, UpgradeAddsSecHeaders) {
  3049. // Set up a redirect to signal we will go from insecure => secure.
  3050. GURL url = test_server()->GetURL(
  3051. kInsecureHost,
  3052. "/server-redirect?" + test_server()->GetURL("/echo").spec());
  3053. ResourceRequest request = CreateResourceRequest("GET", url);
  3054. base::RunLoop delete_run_loop;
  3055. mojo::Remote<mojom::URLLoader> loader;
  3056. std::unique_ptr<URLLoader> url_loader;
  3057. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3058. url_loader = std::make_unique<URLLoader>(
  3059. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3060. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  3061. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3062. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3063. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3064. mojo::NullRemote() /* cookie_observer */,
  3065. mojo::NullRemote() /* url_loader_network_observer */,
  3066. /*devtools_observer=*/mojo::NullRemote(),
  3067. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3068. /*third_party_cookies_enabled=*/true);
  3069. client()->RunUntilRedirectReceived();
  3070. // The initial request is received when the redirect before it has been
  3071. // followed. It should have no added Sec- headers as it is not trustworthy.
  3072. const auto& request_headers1 = sent_request().headers;
  3073. EXPECT_EQ(request_headers1.end(), request_headers1.find("Sec-Fetch-Site"));
  3074. EXPECT_EQ(request_headers1.end(), request_headers1.find("Sec-Fetch-User"));
  3075. // Now follow the redirect to the final destination and validate again.
  3076. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3077. client()->RunUntilComplete();
  3078. delete_run_loop.Run();
  3079. // The Sec-Fetch-Site header should have been added again since we are now on
  3080. // a trustworthy url again.
  3081. const auto& request_headers2 = sent_request().headers;
  3082. EXPECT_EQ("cross-site", request_headers2.find("Sec-Fetch-Site")->second);
  3083. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-Fetch-User"));
  3084. }
  3085. // Validate Sec- prefixed headers are properly handled when redirecting from
  3086. // secure => insecure urls. All Sec-CH- and Sec-Fetch- prefixed
  3087. // headers should be removed.
  3088. TEST_F(URLLoaderTest, DowngradeRemovesSecHeaders) {
  3089. // Set up a redirect to signal we will go from secure => insecure.
  3090. GURL url = test_server()->GetURL(
  3091. "/server-redirect?" +
  3092. test_server()->GetURL(kInsecureHost, "/echo").spec());
  3093. // Add some initial headers to ensure the right ones are removed and
  3094. // everything else is left alone.
  3095. ResourceRequest request = CreateResourceRequest("GET", url);
  3096. request.headers.SetHeader("Sec-CH-UA", "Value1");
  3097. request.headers.SetHeader("Sec-Other-Type", "Value2");
  3098. request.headers.SetHeader("Other-Header", "Value3");
  3099. base::RunLoop delete_run_loop;
  3100. mojo::Remote<mojom::URLLoader> loader;
  3101. std::unique_ptr<URLLoader> url_loader;
  3102. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3103. url_loader = std::make_unique<URLLoader>(
  3104. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3105. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  3106. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3107. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3108. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3109. mojo::NullRemote() /* cookie_observer */,
  3110. mojo::NullRemote() /* url_loader_network_observer */,
  3111. /*devtools_observer=*/mojo::NullRemote(),
  3112. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3113. /*third_party_cookies_enabled=*/true);
  3114. client()->RunUntilRedirectReceived();
  3115. // The initial request is received when the redirect before it has been
  3116. // followed. It should have all the Sec- headers as it is trustworthy. It
  3117. // should also have added a Sec-Fetch-Site header
  3118. const auto& request_headers1 = sent_request().headers;
  3119. EXPECT_EQ("Value1", request_headers1.find("Sec-CH-UA")->second);
  3120. EXPECT_EQ("Value2", request_headers1.find("Sec-Other-Type")->second);
  3121. EXPECT_EQ("Value3", request_headers1.find("Other-Header")->second);
  3122. EXPECT_EQ("same-origin", request_headers1.find("Sec-Fetch-Site")->second);
  3123. EXPECT_EQ(request_headers1.end(), request_headers1.find("Sec-Fetch-User"));
  3124. // Now follow the redirect to the final destination and validate again.
  3125. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3126. client()->RunUntilComplete();
  3127. delete_run_loop.Run();
  3128. // We should have removed our special Sec-CH- and Sec-Fetch- prefixed headers
  3129. // and left the others. We are now operating on an un-trustworthy context.
  3130. const auto& request_headers2 = sent_request().headers;
  3131. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-CH-UA"));
  3132. EXPECT_EQ("Value2", request_headers2.find("Sec-Other-Type")->second);
  3133. EXPECT_EQ("Value3", request_headers2.find("Other-Header")->second);
  3134. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-Fetch-Site"));
  3135. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-Fetch-User"));
  3136. }
  3137. // Validate Sec- prefixed headers are properly handled when redirecting from
  3138. // secure => insecure => secure urls.The headers on insecure
  3139. // urls should be removed and Sec-Fetch-Site should be re-added on secure ones.
  3140. TEST_F(URLLoaderTest, RedirectChainRemovesAndAddsSecHeaders) {
  3141. // Set up a redirect to signal we will go from secure => insecure => secure.
  3142. GURL insecure_upgrade_url = test_server()->GetURL(
  3143. kInsecureHost,
  3144. "/server-redirect?" + test_server()->GetURL("/echo").spec());
  3145. GURL url =
  3146. test_server()->GetURL("/server-redirect?" + insecure_upgrade_url.spec());
  3147. // Add some initial headers to ensure the right ones are removed and
  3148. // everything else is left alone.
  3149. ResourceRequest request = CreateResourceRequest("GET", url);
  3150. request.headers.SetHeader("Sec-CH-UA", "Value1");
  3151. request.headers.SetHeader("Sec-Other-Type", "Value2");
  3152. request.headers.SetHeader("Other-Header", "Value3");
  3153. base::RunLoop delete_run_loop;
  3154. mojo::Remote<mojom::URLLoader> loader;
  3155. std::unique_ptr<URLLoader> url_loader;
  3156. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3157. url_loader = std::make_unique<URLLoader>(
  3158. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3159. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  3160. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3161. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3162. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3163. mojo::NullRemote() /* cookie_observer */,
  3164. mojo::NullRemote() /* url_loader_network_observer */,
  3165. /*devtools_observer=*/mojo::NullRemote(),
  3166. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3167. /*third_party_cookies_enabled=*/true);
  3168. client()->RunUntilRedirectReceived();
  3169. // The initial request is received when the redirect before it has been
  3170. // followed. It should have all the Sec- headers as it is trustworthy. It
  3171. // should also have added a Sec-Fetch-Site header
  3172. const auto& request_headers1 = sent_request().headers;
  3173. EXPECT_EQ("Value1", request_headers1.find("Sec-CH-UA")->second);
  3174. EXPECT_EQ("Value2", request_headers1.find("Sec-Other-Type")->second);
  3175. EXPECT_EQ("Value3", request_headers1.find("Other-Header")->second);
  3176. EXPECT_EQ("same-origin", request_headers1.find("Sec-Fetch-Site")->second);
  3177. EXPECT_EQ(request_headers1.end(), request_headers1.find("Sec-Fetch-User"));
  3178. // Follow our redirect and then verify again.
  3179. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3180. client()->ClearHasReceivedRedirect();
  3181. client()->RunUntilRedirectReceived();
  3182. // Special Sec-CH- and Sec-Fetch- prefixed headers should have been removed
  3183. // and the others left alone. We are now operating on an un-trustworthy
  3184. // context.
  3185. const auto& request_headers2 = sent_request().headers;
  3186. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-CH-UA"));
  3187. EXPECT_EQ("Value2", request_headers2.find("Sec-Other-Type")->second);
  3188. EXPECT_EQ("Value3", request_headers2.find("Other-Header")->second);
  3189. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-Fetch-Site"));
  3190. EXPECT_EQ(request_headers2.end(), request_headers2.find("Sec-Fetch-User"));
  3191. // Now follow the final redirect back to a trustworthy destination and
  3192. // re-validate.
  3193. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3194. client()->RunUntilComplete();
  3195. delete_run_loop.Run();
  3196. const auto& request_headers3 = sent_request().headers;
  3197. EXPECT_EQ(request_headers3.end(), request_headers3.find("Sec-CH-UA"));
  3198. EXPECT_EQ("Value2", request_headers3.find("Sec-Other-Type")->second);
  3199. EXPECT_EQ("Value3", request_headers3.find("Other-Header")->second);
  3200. EXPECT_EQ("cross-site", request_headers3.find("Sec-Fetch-Site")->second);
  3201. EXPECT_EQ(request_headers3.end(), request_headers3.find("Sec-Fetch-User"));
  3202. }
  3203. // Validate Sec-Fetch-User header is properly handled.
  3204. TEST_F(URLLoaderTest, RedirectSecHeadersUser) {
  3205. GURL url = test_server()->GetURL("/server-redirect?" +
  3206. test_server()->GetURL("/echo").spec());
  3207. // Add some initial headers to ensure the right ones are removed and
  3208. // everything else is left alone.
  3209. ResourceRequest request = CreateResourceRequest("GET", url);
  3210. request.trusted_params->has_user_activation = true;
  3211. base::RunLoop delete_run_loop;
  3212. mojo::PendingRemote<mojom::URLLoader> loader;
  3213. std::unique_ptr<URLLoader> url_loader;
  3214. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3215. url_loader = std::make_unique<URLLoader>(
  3216. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3217. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  3218. request, client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3219. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3220. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3221. mojo::NullRemote() /* cookie_observer */,
  3222. mojo::NullRemote() /* url_loader_network_observer */,
  3223. /*devtools_observer=*/mojo::NullRemote(),
  3224. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3225. /*third_party_cookies_enabled=*/true);
  3226. client()->RunUntilRedirectReceived();
  3227. const auto& request_headers = sent_request().headers;
  3228. EXPECT_EQ("same-origin", request_headers.find("Sec-Fetch-Site")->second);
  3229. EXPECT_EQ("?1", request_headers.find("Sec-Fetch-User")->second);
  3230. }
  3231. // Validate Sec-Fetch-User header cannot be modified by manually set the value.
  3232. TEST_F(URLLoaderTest, RedirectDirectlyModifiedSecHeadersUser) {
  3233. GURL url = test_server()->GetURL("/server-redirect?" +
  3234. test_server()->GetURL("/echo").spec());
  3235. // Try to modify `Sec-Fetch-User` directly.
  3236. ResourceRequest request = CreateResourceRequest("GET", url);
  3237. request.headers.SetHeader("Sec-Fetch-User", "?1");
  3238. request.headers.SetHeader("Sec-Fetch-Dest", "embed");
  3239. base::RunLoop delete_run_loop;
  3240. mojo::PendingRemote<mojom::URLLoader> loader;
  3241. std::unique_ptr<URLLoader> url_loader;
  3242. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3243. url_loader = std::make_unique<URLLoader>(
  3244. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3245. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  3246. request, client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3247. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3248. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3249. mojo::NullRemote() /* cookie_observer */,
  3250. mojo::NullRemote() /* url_loader_network_observer */,
  3251. /*devtools_observer=*/mojo::NullRemote(),
  3252. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3253. /*third_party_cookies_enabled=*/true);
  3254. client()->RunUntilRedirectReceived();
  3255. const auto& request_headers = sent_request().headers;
  3256. EXPECT_EQ(request_headers.end(), request_headers.find("Sec-Fetch-User"));
  3257. EXPECT_EQ("empty", request_headers.find("Sec-Fetch-Dest")->second);
  3258. }
  3259. // A mock URLRequestJob which simulates an HTTPS request with a certificate
  3260. // error.
  3261. class MockHTTPSURLRequestJob : public net::URLRequestTestJob {
  3262. public:
  3263. MockHTTPSURLRequestJob(net::URLRequest* request,
  3264. const std::string& response_headers,
  3265. const std::string& response_data,
  3266. bool auto_advance)
  3267. : net::URLRequestTestJob(request,
  3268. response_headers,
  3269. response_data,
  3270. auto_advance) {}
  3271. MockHTTPSURLRequestJob(const MockHTTPSURLRequestJob&) = delete;
  3272. MockHTTPSURLRequestJob& operator=(const MockHTTPSURLRequestJob&) = delete;
  3273. ~MockHTTPSURLRequestJob() override = default;
  3274. // net::URLRequestTestJob:
  3275. void GetResponseInfo(net::HttpResponseInfo* info) override {
  3276. // Get the original response info, but override the SSL info.
  3277. net::URLRequestJob::GetResponseInfo(info);
  3278. info->ssl_info.cert =
  3279. net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
  3280. info->ssl_info.cert_status = net::CERT_STATUS_DATE_INVALID;
  3281. }
  3282. };
  3283. class MockHTTPSJobURLRequestInterceptor : public net::URLRequestInterceptor {
  3284. public:
  3285. MockHTTPSJobURLRequestInterceptor() {}
  3286. ~MockHTTPSJobURLRequestInterceptor() override {}
  3287. // net::URLRequestInterceptor:
  3288. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  3289. net::URLRequest* request) const override {
  3290. return std::make_unique<MockHTTPSURLRequestJob>(request, std::string(),
  3291. "dummy response", true);
  3292. }
  3293. };
  3294. // Tests that |cert_status| is set on the resource response.
  3295. TEST_F(URLLoaderTest, CertStatusOnResponse) {
  3296. net::URLRequestFilter::GetInstance()->ClearHandlers();
  3297. net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
  3298. "https", "example.test",
  3299. std::unique_ptr<net::URLRequestInterceptor>(
  3300. new MockHTTPSJobURLRequestInterceptor()));
  3301. EXPECT_EQ(net::OK, Load(GURL("https://example.test/")));
  3302. EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
  3303. client()->response_head()->cert_status);
  3304. }
  3305. // Verifies if URLLoader works well with ResourceScheduler.
  3306. TEST_F(URLLoaderTest, ResourceSchedulerIntegration) {
  3307. // ResourceScheduler limits the number of connections for the same host
  3308. // by 6.
  3309. constexpr int kRepeat = 6;
  3310. constexpr char kPath[] = "/hello.html";
  3311. net::EmbeddedTestServer server;
  3312. // This is needed to stall all requests to the server.
  3313. net::test_server::ControllableHttpResponse response_controllers[kRepeat] = {
  3314. {&server, kPath}, {&server, kPath}, {&server, kPath},
  3315. {&server, kPath}, {&server, kPath}, {&server, kPath},
  3316. };
  3317. ASSERT_TRUE(server.Start());
  3318. ResourceRequest request = CreateResourceRequest("GET", server.GetURL(kPath));
  3319. request.load_flags = net::LOAD_DISABLE_CACHE;
  3320. request.priority = net::IDLE;
  3321. // Fill up the ResourceScheduler with delayable requests.
  3322. std::vector<
  3323. std::pair<std::unique_ptr<URLLoader>, mojo::Remote<mojom::URLLoader>>>
  3324. loaders;
  3325. context().mutable_factory_params().process_id = kProcessId;
  3326. context().mutable_factory_params().is_corb_enabled = false;
  3327. for (int i = 0; i < kRepeat; ++i) {
  3328. TestURLLoaderClient client;
  3329. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  3330. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3331. context(), NeverInvokedDeleteLoaderCallback(),
  3332. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  3333. client.CreateRemote(), nullptr /* sync_url_loader_client */,
  3334. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3335. 0 /* keepalive_request_size */, nullptr,
  3336. nullptr /* trust_token_helper */,
  3337. mojo::NullRemote() /* cookie_observer */,
  3338. mojo::NullRemote() /* url_loader_network_observer */,
  3339. /*devtools_observer=*/mojo::NullRemote(),
  3340. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3341. /*third_party_cookies_enabled=*/true);
  3342. loaders.emplace_back(
  3343. std::make_pair(std::move(url_loader), std::move(loader_remote)));
  3344. }
  3345. base::RunLoop().RunUntilIdle();
  3346. for (const auto& pair : loaders) {
  3347. URLLoader* loader = pair.first.get();
  3348. ASSERT_NE(loader, nullptr);
  3349. EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_RESPONSE, loader->GetLoadState());
  3350. }
  3351. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  3352. std::unique_ptr<URLLoader> loader = std::make_unique<URLLoader>(
  3353. context(), NeverInvokedDeleteLoaderCallback(),
  3354. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  3355. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3356. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3357. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3358. mojo::NullRemote() /* cookie_observer */,
  3359. mojo::NullRemote() /* url_loader_network_observer */,
  3360. /*devtools_observer=*/mojo::NullRemote(),
  3361. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3362. /*third_party_cookies_enabled=*/true);
  3363. base::RunLoop().RunUntilIdle();
  3364. // Make sure that the ResourceScheduler throttles this request.
  3365. EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_DELEGATE, loader->GetLoadState());
  3366. loader->SetPriority(net::HIGHEST, 0 /* intra_priority_value */);
  3367. base::RunLoop().RunUntilIdle();
  3368. // Make sure that the ResourceScheduler stops throtting.
  3369. EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET,
  3370. loader->GetLoadState());
  3371. }
  3372. // This tests that case where a read pipe is closed while there's a post task to
  3373. // invoke ReadMore.
  3374. TEST_F(URLLoaderTest, ReadPipeClosedWhileReadTaskPosted) {
  3375. AddEternalSyncReadsInterceptor();
  3376. ResourceRequest request = CreateResourceRequest(
  3377. "GET", EternalSyncReadsInterceptor::GetSingleByteURL());
  3378. base::RunLoop delete_run_loop;
  3379. mojo::PendingRemote<mojom::URLLoader> loader;
  3380. std::unique_ptr<URLLoader> url_loader;
  3381. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3382. context().mutable_factory_params().is_corb_enabled = false;
  3383. url_loader = std::make_unique<URLLoader>(
  3384. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3385. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  3386. request, client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3387. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3388. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3389. mojo::NullRemote() /* cookie_observer */,
  3390. mojo::NullRemote() /* url_loader_network_observer */,
  3391. /*devtools_observer=*/mojo::NullRemote(),
  3392. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3393. /*third_party_cookies_enabled=*/true);
  3394. client()->RunUntilResponseBodyArrived();
  3395. client()->response_body_release();
  3396. delete_run_loop.Run();
  3397. }
  3398. class FakeSSLPrivateKeyImpl : public network::mojom::SSLPrivateKey {
  3399. public:
  3400. explicit FakeSSLPrivateKeyImpl(
  3401. scoped_refptr<net::SSLPrivateKey> ssl_private_key)
  3402. : ssl_private_key_(std::move(ssl_private_key)) {}
  3403. FakeSSLPrivateKeyImpl(const FakeSSLPrivateKeyImpl&) = delete;
  3404. FakeSSLPrivateKeyImpl& operator=(const FakeSSLPrivateKeyImpl&) = delete;
  3405. ~FakeSSLPrivateKeyImpl() override {}
  3406. // network::mojom::SSLPrivateKey:
  3407. void Sign(uint16_t algorithm,
  3408. const std::vector<uint8_t>& input,
  3409. network::mojom::SSLPrivateKey::SignCallback callback) override {
  3410. base::span<const uint8_t> input_span(input);
  3411. ssl_private_key_->Sign(
  3412. algorithm, input_span,
  3413. base::BindOnce(&FakeSSLPrivateKeyImpl::Callback, base::Unretained(this),
  3414. std::move(callback)));
  3415. }
  3416. private:
  3417. void Callback(network::mojom::SSLPrivateKey::SignCallback callback,
  3418. net::Error net_error,
  3419. const std::vector<uint8_t>& signature) {
  3420. std::move(callback).Run(static_cast<int32_t>(net_error), signature);
  3421. }
  3422. scoped_refptr<net::SSLPrivateKey> ssl_private_key_;
  3423. };
  3424. using CookieAccessType = mojom::CookieAccessDetails::Type;
  3425. class MockCookieObserver : public network::mojom::CookieAccessObserver {
  3426. public:
  3427. explicit MockCookieObserver(
  3428. absl::optional<CookieAccessType> access_type = absl::nullopt)
  3429. : access_type_(access_type) {}
  3430. ~MockCookieObserver() override = default;
  3431. struct CookieDetails {
  3432. CookieDetails(const mojom::CookieAccessDetailsPtr& details,
  3433. const mojom::CookieOrLineWithAccessResultPtr& cookie)
  3434. : type(details->type),
  3435. cookie_or_line(std::move(cookie->cookie_or_line)),
  3436. is_include(cookie->access_result.status.IsInclude()),
  3437. url(details->url),
  3438. status(cookie->access_result.status) {}
  3439. CookieAccessType type;
  3440. mojom::CookieOrLinePtr cookie_or_line;
  3441. bool is_include;
  3442. // The full details are available for the tests to query manually, but
  3443. // they are not covered by operator== (and testing::ElementsAre).
  3444. GURL url;
  3445. net::CookieInclusionStatus status;
  3446. };
  3447. mojo::PendingRemote<mojom::CookieAccessObserver> GetRemote() {
  3448. mojo::PendingRemote<mojom::CookieAccessObserver> remote;
  3449. receivers_.Add(this, remote.InitWithNewPipeAndPassReceiver());
  3450. return remote;
  3451. }
  3452. void OnCookiesAccessed(mojom::CookieAccessDetailsPtr details) override {
  3453. if (access_type_ && access_type_ != details->type)
  3454. return;
  3455. for (const auto& cookie_with_status : details->cookie_list) {
  3456. observed_cookies_.emplace_back(details, cookie_with_status);
  3457. }
  3458. if (wait_for_cookie_count_ &&
  3459. observed_cookies().size() >= wait_for_cookie_count_) {
  3460. std::move(wait_for_cookies_quit_closure_).Run();
  3461. }
  3462. }
  3463. void WaitForCookies(size_t cookie_count) {
  3464. if (observed_cookies_.size() < cookie_count) {
  3465. wait_for_cookie_count_ = cookie_count;
  3466. base::RunLoop run_loop;
  3467. wait_for_cookies_quit_closure_ = run_loop.QuitClosure();
  3468. run_loop.Run();
  3469. }
  3470. EXPECT_EQ(observed_cookies_.size(), cookie_count);
  3471. }
  3472. void Clone(
  3473. mojo::PendingReceiver<mojom::CookieAccessObserver> observer) override {
  3474. receivers_.Add(this, std::move(observer));
  3475. }
  3476. const std::vector<CookieDetails>& observed_cookies() {
  3477. return observed_cookies_;
  3478. }
  3479. private:
  3480. absl::optional<CookieAccessType> access_type_;
  3481. size_t wait_for_cookie_count_ = 0;
  3482. base::OnceClosure wait_for_cookies_quit_closure_;
  3483. std::vector<CookieDetails> observed_cookies_;
  3484. mojo::ReceiverSet<mojom::CookieAccessObserver> receivers_;
  3485. };
  3486. MATCHER_P3(MatchesCookieDetails, type, cookie_or_line, is_include, "") {
  3487. return testing::ExplainMatchResult(
  3488. testing::AllOf(
  3489. testing::Field(&MockCookieObserver::CookieDetails::type, type),
  3490. testing::Field(&MockCookieObserver::CookieDetails::cookie_or_line,
  3491. cookie_or_line),
  3492. testing::Field(&MockCookieObserver::CookieDetails::is_include,
  3493. is_include)),
  3494. arg, result_listener);
  3495. }
  3496. // Responds certificate request with previously set responses.
  3497. class ClientCertAuthObserver : public TestURLLoaderNetworkObserver {
  3498. public:
  3499. ClientCertAuthObserver() = default;
  3500. ~ClientCertAuthObserver() override = default;
  3501. enum class CertificateResponse {
  3502. INVALID = -1,
  3503. URL_LOADER_REQUEST_CANCELLED,
  3504. CANCEL_CERTIFICATE_SELECTION,
  3505. NULL_CERTIFICATE,
  3506. VALID_CERTIFICATE_SIGNATURE,
  3507. INVALID_CERTIFICATE_SIGNATURE,
  3508. DESTROY_CLIENT_CERT_RESPONDER,
  3509. };
  3510. enum class CredentialsResponse {
  3511. NO_CREDENTIALS,
  3512. CORRECT_CREDENTIALS,
  3513. INCORRECT_CREDENTIALS_THEN_CORRECT_ONES,
  3514. };
  3515. void OnAuthRequired(
  3516. const absl::optional<base::UnguessableToken>& window_id,
  3517. uint32_t request_id,
  3518. const GURL& url,
  3519. bool first_auth_attempt,
  3520. const net::AuthChallengeInfo& auth_info,
  3521. const scoped_refptr<net::HttpResponseHeaders>& head_headers,
  3522. mojo::PendingRemote<mojom::AuthChallengeResponder>
  3523. auth_challenge_responder) override {
  3524. switch (credentials_response_) {
  3525. case CredentialsResponse::NO_CREDENTIALS:
  3526. auth_credentials_ = absl::nullopt;
  3527. break;
  3528. case CredentialsResponse::CORRECT_CREDENTIALS:
  3529. auth_credentials_ = net::AuthCredentials(u"USER", u"PASS");
  3530. break;
  3531. case CredentialsResponse::INCORRECT_CREDENTIALS_THEN_CORRECT_ONES:
  3532. auth_credentials_ = net::AuthCredentials(u"USER", u"FAIL");
  3533. credentials_response_ = CredentialsResponse::CORRECT_CREDENTIALS;
  3534. break;
  3535. }
  3536. mojo::Remote<mojom::AuthChallengeResponder> auth_challenge_responder_remote(
  3537. std::move(auth_challenge_responder));
  3538. auth_challenge_responder_remote->OnAuthCredentials(auth_credentials_);
  3539. ++on_auth_required_call_counter_;
  3540. last_seen_response_headers_ = head_headers;
  3541. }
  3542. void OnCertificateRequested(
  3543. const absl::optional<base::UnguessableToken>& window_id,
  3544. const scoped_refptr<net::SSLCertRequestInfo>& cert_info,
  3545. mojo::PendingRemote<mojom::ClientCertificateResponder>
  3546. client_cert_responder_remote) override {
  3547. mojo::Remote<mojom::ClientCertificateResponder> client_cert_responder(
  3548. std::move(client_cert_responder_remote));
  3549. switch (certificate_response_) {
  3550. case CertificateResponse::INVALID:
  3551. NOTREACHED();
  3552. break;
  3553. case CertificateResponse::URL_LOADER_REQUEST_CANCELLED:
  3554. ASSERT_TRUE(url_loader_remote_);
  3555. url_loader_remote_->reset();
  3556. break;
  3557. case CertificateResponse::CANCEL_CERTIFICATE_SELECTION:
  3558. client_cert_responder->CancelRequest();
  3559. break;
  3560. case CertificateResponse::NULL_CERTIFICATE:
  3561. client_cert_responder->ContinueWithoutCertificate();
  3562. break;
  3563. case CertificateResponse::VALID_CERTIFICATE_SIGNATURE:
  3564. case CertificateResponse::INVALID_CERTIFICATE_SIGNATURE:
  3565. client_cert_responder->ContinueWithCertificate(
  3566. std::move(certificate_), provider_name_, algorithm_preferences_,
  3567. std::move(ssl_private_key_remote_));
  3568. break;
  3569. case CertificateResponse::DESTROY_CLIENT_CERT_RESPONDER:
  3570. // Send no response and let the local variable be destroyed.
  3571. break;
  3572. }
  3573. ++on_certificate_requested_counter_;
  3574. }
  3575. void set_certificate_response(CertificateResponse certificate_response) {
  3576. certificate_response_ = certificate_response;
  3577. }
  3578. void set_private_key(scoped_refptr<net::SSLPrivateKey> ssl_private_key) {
  3579. ssl_private_key_ = std::move(ssl_private_key);
  3580. provider_name_ = ssl_private_key_->GetProviderName();
  3581. algorithm_preferences_ = ssl_private_key_->GetAlgorithmPreferences();
  3582. mojo::MakeSelfOwnedReceiver(
  3583. std::make_unique<FakeSSLPrivateKeyImpl>(std::move(ssl_private_key_)),
  3584. ssl_private_key_remote_.InitWithNewPipeAndPassReceiver());
  3585. }
  3586. void set_certificate(scoped_refptr<net::X509Certificate> certificate) {
  3587. certificate_ = std::move(certificate);
  3588. }
  3589. int on_certificate_requested_counter() {
  3590. return on_certificate_requested_counter_;
  3591. }
  3592. void set_url_loader_remote(
  3593. mojo::Remote<mojom::URLLoader>* url_loader_remote) {
  3594. url_loader_remote_ = url_loader_remote;
  3595. }
  3596. void set_credentials_response(CredentialsResponse credentials_response) {
  3597. credentials_response_ = credentials_response;
  3598. }
  3599. int on_auth_required_call_counter() { return on_auth_required_call_counter_; }
  3600. net::HttpResponseHeaders* last_seen_response_headers() {
  3601. return last_seen_response_headers_.get();
  3602. }
  3603. private:
  3604. CredentialsResponse credentials_response_ =
  3605. CredentialsResponse::NO_CREDENTIALS;
  3606. absl::optional<net::AuthCredentials> auth_credentials_;
  3607. int on_auth_required_call_counter_ = 0;
  3608. scoped_refptr<net::HttpResponseHeaders> last_seen_response_headers_;
  3609. CertificateResponse certificate_response_ = CertificateResponse::INVALID;
  3610. scoped_refptr<net::SSLPrivateKey> ssl_private_key_;
  3611. scoped_refptr<net::X509Certificate> certificate_;
  3612. mojo::PendingRemote<network::mojom::SSLPrivateKey> ssl_private_key_remote_;
  3613. std::string provider_name_;
  3614. std::vector<uint16_t> algorithm_preferences_;
  3615. int on_certificate_requested_counter_ = 0;
  3616. raw_ptr<mojo::Remote<mojom::URLLoader>> url_loader_remote_ = nullptr;
  3617. };
  3618. TEST_F(URLLoaderTest, SetAuth) {
  3619. ClientCertAuthObserver client_auth_observer;
  3620. client_auth_observer.set_credentials_response(
  3621. ClientCertAuthObserver::CredentialsResponse::CORRECT_CREDENTIALS);
  3622. ResourceRequest request =
  3623. CreateResourceRequest("GET", test_server()->GetURL(kTestAuthURL));
  3624. base::RunLoop delete_run_loop;
  3625. mojo::PendingRemote<mojom::URLLoader> loader;
  3626. context().mutable_factory_params().process_id = kProcessId;
  3627. context().mutable_factory_params().is_corb_enabled = false;
  3628. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3629. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3630. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  3631. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3632. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3633. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3634. mojo::NullRemote() /* cookie_observer */,
  3635. client_auth_observer.Bind() /* url_loader_network_observer */,
  3636. /*devtools_observer=*/mojo::NullRemote(),
  3637. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3638. /*third_party_cookies_enabled=*/true);
  3639. base::RunLoop().RunUntilIdle();
  3640. ASSERT_TRUE(url_loader);
  3641. client()->RunUntilResponseBodyArrived();
  3642. EXPECT_TRUE(client()->has_received_response());
  3643. EXPECT_FALSE(client()->has_received_completion());
  3644. // Spin the message loop until the delete callback is invoked, and then delete
  3645. // the URLLoader.
  3646. delete_run_loop.Run();
  3647. client()->RunUntilComplete();
  3648. EXPECT_TRUE(client()->has_received_completion());
  3649. scoped_refptr<net::HttpResponseHeaders> headers =
  3650. client()->response_head()->headers;
  3651. ASSERT_TRUE(headers);
  3652. EXPECT_EQ(200, headers->response_code());
  3653. EXPECT_EQ(1, client_auth_observer.on_auth_required_call_counter());
  3654. ASSERT_FALSE(url_loader);
  3655. EXPECT_FALSE(client()->response_head()->auth_challenge_info.has_value());
  3656. }
  3657. TEST_F(URLLoaderTest, CancelAuth) {
  3658. ClientCertAuthObserver client_auth_observer;
  3659. client_auth_observer.set_credentials_response(
  3660. ClientCertAuthObserver::CredentialsResponse::NO_CREDENTIALS);
  3661. ResourceRequest request =
  3662. CreateResourceRequest("GET", test_server()->GetURL(kTestAuthURL));
  3663. base::RunLoop delete_run_loop;
  3664. mojo::PendingRemote<mojom::URLLoader> loader;
  3665. context().mutable_factory_params().process_id = kProcessId;
  3666. context().mutable_factory_params().is_corb_enabled = false;
  3667. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3668. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3669. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  3670. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3671. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3672. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3673. mojo::NullRemote() /* cookie_observer */,
  3674. client_auth_observer.Bind() /* url_loader_network_observer */,
  3675. /*devtools_observer=*/mojo::NullRemote(),
  3676. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3677. /*third_party_cookies_enabled=*/true);
  3678. base::RunLoop().RunUntilIdle();
  3679. ASSERT_TRUE(url_loader);
  3680. client()->RunUntilResponseBodyArrived();
  3681. EXPECT_TRUE(client()->has_received_response());
  3682. EXPECT_FALSE(client()->has_received_completion());
  3683. // Spin the message loop until the delete callback is invoked, and then delete
  3684. // the URLLoader.
  3685. delete_run_loop.Run();
  3686. client()->RunUntilComplete();
  3687. EXPECT_TRUE(client()->has_received_completion());
  3688. scoped_refptr<net::HttpResponseHeaders> headers =
  3689. client()->response_head()->headers;
  3690. ASSERT_TRUE(headers);
  3691. EXPECT_EQ(401, headers->response_code());
  3692. EXPECT_EQ(1, client_auth_observer.on_auth_required_call_counter());
  3693. ASSERT_FALSE(url_loader);
  3694. }
  3695. TEST_F(URLLoaderTest, TwoChallenges) {
  3696. ClientCertAuthObserver client_auth_observer;
  3697. client_auth_observer.set_credentials_response(
  3698. ClientCertAuthObserver::CredentialsResponse::
  3699. INCORRECT_CREDENTIALS_THEN_CORRECT_ONES);
  3700. ResourceRequest request =
  3701. CreateResourceRequest("GET", test_server()->GetURL(kTestAuthURL));
  3702. base::RunLoop delete_run_loop;
  3703. mojo::PendingRemote<mojom::URLLoader> loader;
  3704. context().mutable_factory_params().process_id = kProcessId;
  3705. context().mutable_factory_params().is_corb_enabled = false;
  3706. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3707. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3708. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  3709. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3710. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3711. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3712. mojo::NullRemote() /* cookie_observer */,
  3713. client_auth_observer.Bind() /* url_loader_network_observer */,
  3714. /*devtools_observer=*/mojo::NullRemote(),
  3715. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3716. /*third_party_cookies_enabled=*/true);
  3717. base::RunLoop().RunUntilIdle();
  3718. ASSERT_TRUE(url_loader);
  3719. client()->RunUntilResponseBodyArrived();
  3720. EXPECT_TRUE(client()->has_received_response());
  3721. EXPECT_FALSE(client()->has_received_completion());
  3722. // Spin the message loop until the delete callback is invoked, and then delete
  3723. // the URLLoader.
  3724. delete_run_loop.Run();
  3725. client()->RunUntilComplete();
  3726. EXPECT_TRUE(client()->has_received_completion());
  3727. scoped_refptr<net::HttpResponseHeaders> headers =
  3728. client()->response_head()->headers;
  3729. ASSERT_TRUE(headers);
  3730. EXPECT_EQ(200, headers->response_code());
  3731. EXPECT_EQ(2, client_auth_observer.on_auth_required_call_counter());
  3732. ASSERT_FALSE(url_loader);
  3733. }
  3734. TEST_F(URLLoaderTest, NoAuthRequiredForFavicon) {
  3735. constexpr char kFaviconTestPage[] = "/has_favicon.html";
  3736. ClientCertAuthObserver client_auth_observer;
  3737. client_auth_observer.set_credentials_response(
  3738. ClientCertAuthObserver::CredentialsResponse::CORRECT_CREDENTIALS);
  3739. ResourceRequest request =
  3740. CreateResourceRequest("GET", test_server()->GetURL(kFaviconTestPage));
  3741. base::RunLoop delete_run_loop;
  3742. mojo::PendingRemote<mojom::URLLoader> loader;
  3743. context().mutable_factory_params().process_id = kProcessId;
  3744. context().mutable_factory_params().is_corb_enabled = false;
  3745. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3746. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3747. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  3748. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3749. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3750. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3751. mojo::NullRemote() /* cookie_observer */,
  3752. client_auth_observer.Bind() /* url_loader_network_observer */,
  3753. /*devtools_observer=*/mojo::NullRemote(),
  3754. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3755. /*third_party_cookies_enabled=*/true);
  3756. base::RunLoop().RunUntilIdle();
  3757. ASSERT_TRUE(url_loader);
  3758. client()->RunUntilResponseBodyArrived();
  3759. EXPECT_TRUE(client()->has_received_response());
  3760. EXPECT_FALSE(client()->has_received_completion());
  3761. // Spin the message loop until the delete callback is invoked, and then delete
  3762. // the URLLoader.
  3763. delete_run_loop.Run();
  3764. client()->RunUntilComplete();
  3765. EXPECT_TRUE(client()->has_received_completion());
  3766. scoped_refptr<net::HttpResponseHeaders> headers =
  3767. client()->response_head()->headers;
  3768. ASSERT_TRUE(headers);
  3769. EXPECT_EQ(200, headers->response_code());
  3770. // No auth required for favicon.
  3771. EXPECT_EQ(0, client_auth_observer.on_auth_required_call_counter());
  3772. ASSERT_FALSE(url_loader);
  3773. }
  3774. TEST_F(URLLoaderTest, HttpAuthResponseHeadersAvailable) {
  3775. ClientCertAuthObserver client_auth_observer;
  3776. client_auth_observer.set_credentials_response(
  3777. ClientCertAuthObserver::CredentialsResponse::CORRECT_CREDENTIALS);
  3778. ResourceRequest request =
  3779. CreateResourceRequest("GET", test_server()->GetURL(kTestAuthURL));
  3780. base::RunLoop delete_run_loop;
  3781. mojo::PendingRemote<mojom::URLLoader> loader;
  3782. context().mutable_factory_params().process_id = kProcessId;
  3783. context().mutable_factory_params().is_corb_enabled = false;
  3784. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3785. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3786. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  3787. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3788. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3789. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3790. mojo::NullRemote() /* cookie_observer */,
  3791. client_auth_observer.Bind() /* url_loader_network_observer */,
  3792. /*devtools_observer=*/mojo::NullRemote(),
  3793. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3794. /*third_party_cookies_enabled=*/true);
  3795. base::RunLoop().RunUntilIdle();
  3796. ASSERT_TRUE(url_loader);
  3797. client()->RunUntilResponseBodyArrived();
  3798. // Spin the message loop until the delete callback is invoked, and then delete
  3799. // the URLLoader.
  3800. delete_run_loop.Run();
  3801. EXPECT_EQ(1, client_auth_observer.on_auth_required_call_counter());
  3802. auto* auth_required_headers =
  3803. client_auth_observer.last_seen_response_headers();
  3804. ASSERT_TRUE(auth_required_headers);
  3805. EXPECT_EQ(auth_required_headers->response_code(), 401);
  3806. }
  3807. // Make sure the client can't call FollowRedirect if there's no pending
  3808. // redirect.
  3809. TEST_F(URLLoaderTest, FollowRedirectTwice) {
  3810. ResourceRequest request = CreateResourceRequest(
  3811. "GET", test_server()->GetURL("/redirect307-to-echo"));
  3812. request.headers.SetHeader("Header1", "Value1");
  3813. request.headers.SetHeader("Header2", "Value2");
  3814. base::RunLoop delete_run_loop;
  3815. mojo::PendingRemote<mojom::URLLoader> loader;
  3816. std::unique_ptr<URLLoader> url_loader;
  3817. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  3818. context().mutable_factory_params().is_corb_enabled = false;
  3819. url_loader = std::make_unique<URLLoader>(
  3820. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3821. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  3822. request, client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3823. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3824. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3825. mojo::NullRemote() /* cookie_observer */,
  3826. mojo::NullRemote() /* url_loader_network_observer */,
  3827. /*devtools_observer=*/mojo::NullRemote(),
  3828. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3829. /*third_party_cookies_enabled=*/true);
  3830. client()->RunUntilRedirectReceived();
  3831. url_loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3832. EXPECT_DCHECK_DEATH(url_loader->FollowRedirect({}, {}, {}, absl::nullopt));
  3833. client()->RunUntilComplete();
  3834. delete_run_loop.Run();
  3835. }
  3836. class TestSSLPrivateKey : public net::SSLPrivateKey {
  3837. public:
  3838. explicit TestSSLPrivateKey(scoped_refptr<net::SSLPrivateKey> key)
  3839. : key_(std::move(key)) {}
  3840. TestSSLPrivateKey(const TestSSLPrivateKey&) = delete;
  3841. TestSSLPrivateKey& operator=(const TestSSLPrivateKey&) = delete;
  3842. void set_fail_signing(bool fail_signing) { fail_signing_ = fail_signing; }
  3843. int sign_count() const { return sign_count_; }
  3844. std::string GetProviderName() override { return key_->GetProviderName(); }
  3845. std::vector<uint16_t> GetAlgorithmPreferences() override {
  3846. return key_->GetAlgorithmPreferences();
  3847. }
  3848. void Sign(uint16_t algorithm,
  3849. base::span<const uint8_t> input,
  3850. SignCallback callback) override {
  3851. sign_count_++;
  3852. if (fail_signing_) {
  3853. base::ThreadTaskRunnerHandle::Get()->PostTask(
  3854. FROM_HERE, base::BindOnce(std::move(callback),
  3855. net::ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED,
  3856. std::vector<uint8_t>()));
  3857. } else {
  3858. key_->Sign(algorithm, input, std::move(callback));
  3859. }
  3860. }
  3861. private:
  3862. ~TestSSLPrivateKey() override = default;
  3863. scoped_refptr<net::SSLPrivateKey> key_;
  3864. bool fail_signing_ = false;
  3865. int sign_count_ = 0;
  3866. };
  3867. #if !BUILDFLAG(IS_IOS)
  3868. TEST_F(URLLoaderTest, ClientAuthRespondTwice) {
  3869. // This tests that one URLLoader can handle two client cert requests.
  3870. net::SSLServerConfig ssl_config;
  3871. ssl_config.client_cert_type =
  3872. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  3873. net::EmbeddedTestServer test_server_1(net::EmbeddedTestServer::TYPE_HTTPS);
  3874. test_server_1.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  3875. test_server_1.AddDefaultHandlers(
  3876. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  3877. ASSERT_TRUE(test_server_1.Start());
  3878. net::EmbeddedTestServer test_server_2(net::EmbeddedTestServer::TYPE_HTTPS);
  3879. test_server_2.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  3880. test_server_2.AddDefaultHandlers(
  3881. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  3882. ASSERT_TRUE(test_server_2.Start());
  3883. std::unique_ptr<net::FakeClientCertIdentity> identity =
  3884. net::FakeClientCertIdentity::CreateFromCertAndKeyFiles(
  3885. net::GetTestCertsDirectory(), "client_1.pem", "client_1.pk8");
  3886. ASSERT_TRUE(identity);
  3887. scoped_refptr<TestSSLPrivateKey> private_key =
  3888. base::MakeRefCounted<TestSSLPrivateKey>(identity->ssl_private_key());
  3889. ClientCertAuthObserver client_cert_observer;
  3890. client_cert_observer.set_certificate_response(
  3891. ClientCertAuthObserver::CertificateResponse::VALID_CERTIFICATE_SIGNATURE);
  3892. client_cert_observer.set_private_key(private_key);
  3893. client_cert_observer.set_certificate(identity->certificate());
  3894. // Create a request to server_1 that will redirect to server_2
  3895. ResourceRequest request = CreateResourceRequest(
  3896. "GET",
  3897. test_server_1.GetURL("/server-redirect-307?" +
  3898. base::EscapeQueryParamValue(
  3899. test_server_2.GetURL("/echo").spec(), true)));
  3900. base::RunLoop delete_run_loop;
  3901. mojo::Remote<mojom::URLLoader> loader;
  3902. std::unique_ptr<URLLoader> url_loader;
  3903. context().mutable_factory_params().process_id = kProcessId;
  3904. context().mutable_factory_params().is_corb_enabled = false;
  3905. url_loader = std::make_unique<URLLoader>(
  3906. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3907. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  3908. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  3909. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  3910. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  3911. mojo::NullRemote() /* cookie_observer */,
  3912. client_cert_observer.Bind() /* url_loader_network_observer */,
  3913. /*devtools_observer=*/mojo::NullRemote(),
  3914. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3915. /*third_party_cookies_enabled=*/true);
  3916. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  3917. EXPECT_EQ(0, private_key->sign_count());
  3918. client()->RunUntilRedirectReceived();
  3919. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  3920. // MockNetworkServiceClient gives away the private key when it invokes
  3921. // ContinueWithCertificate, so we have to give it the key again.
  3922. client_cert_observer.set_private_key(private_key);
  3923. client()->RunUntilComplete();
  3924. delete_run_loop.Run();
  3925. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  3926. EXPECT_EQ(2, client_cert_observer.on_certificate_requested_counter());
  3927. EXPECT_EQ(2, private_key->sign_count());
  3928. }
  3929. TEST_F(URLLoaderTest, ClientAuthDestroyResponder) {
  3930. // When URLLoader receives no message from the ClientCertificateResponder and
  3931. // its connection errors out, we expect the request to be canceled rather than
  3932. // just hang.
  3933. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  3934. net::SSLServerConfig ssl_config;
  3935. ssl_config.client_cert_type =
  3936. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  3937. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  3938. test_server.AddDefaultHandlers(
  3939. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  3940. ASSERT_TRUE(test_server.Start());
  3941. ClientCertAuthObserver client_cert_observer;
  3942. client_cert_observer.set_certificate_response(
  3943. ClientCertAuthObserver::CertificateResponse::
  3944. DESTROY_CLIENT_CERT_RESPONDER);
  3945. ResourceRequest request =
  3946. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  3947. base::RunLoop delete_run_loop;
  3948. mojo::Remote<mojom::URLLoader> loader;
  3949. context().mutable_factory_params().process_id = kProcessId;
  3950. context().mutable_factory_params().is_corb_enabled = false;
  3951. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3952. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3953. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  3954. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  3955. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  3956. nullptr /* trust_token_helper */,
  3957. mojo::NullRemote() /* cookie_observer */,
  3958. client_cert_observer.Bind() /* url_loader_network_observer */,
  3959. /*devtools_observer=*/mojo::NullRemote(),
  3960. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3961. /*third_party_cookies_enabled=*/true);
  3962. client_cert_observer.set_url_loader_remote(&loader);
  3963. RunUntilIdle();
  3964. ASSERT_TRUE(url_loader);
  3965. client()->RunUntilComplete();
  3966. EXPECT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
  3967. client()->completion_status().error_code);
  3968. }
  3969. TEST_F(URLLoaderTest, ClientAuthCancelConnection) {
  3970. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  3971. net::SSLServerConfig ssl_config;
  3972. ssl_config.client_cert_type =
  3973. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  3974. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  3975. test_server.AddDefaultHandlers(
  3976. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  3977. ASSERT_TRUE(test_server.Start());
  3978. ClientCertAuthObserver client_cert_observer;
  3979. client_cert_observer.set_certificate_response(
  3980. ClientCertAuthObserver::CertificateResponse::
  3981. URL_LOADER_REQUEST_CANCELLED);
  3982. ResourceRequest request =
  3983. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  3984. base::RunLoop delete_run_loop;
  3985. mojo::Remote<mojom::URLLoader> loader;
  3986. context().mutable_factory_params().process_id = kProcessId;
  3987. context().mutable_factory_params().is_corb_enabled = false;
  3988. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  3989. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  3990. loader.BindNewPipeAndPassReceiver(), 0, request, client()->CreateRemote(),
  3991. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  3992. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  3993. nullptr /* trust_token_helper */,
  3994. mojo::NullRemote() /* cookie_observer */,
  3995. client_cert_observer.Bind() /* url_loader_network_observer */,
  3996. /*devtools_observer=*/mojo::NullRemote(),
  3997. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  3998. /*third_party_cookies_enabled=*/true);
  3999. client_cert_observer.set_url_loader_remote(&loader);
  4000. RunUntilIdle();
  4001. ASSERT_TRUE(url_loader);
  4002. client()->RunUntilComplete();
  4003. EXPECT_EQ(net::ERR_FAILED, client()->completion_status().error_code);
  4004. }
  4005. TEST_F(URLLoaderTest, ClientAuthCancelCertificateSelection) {
  4006. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4007. net::SSLServerConfig ssl_config;
  4008. ssl_config.client_cert_type =
  4009. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  4010. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4011. test_server.AddDefaultHandlers(
  4012. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4013. ASSERT_TRUE(test_server.Start());
  4014. ClientCertAuthObserver client_cert_observer;
  4015. client_cert_observer.set_certificate_response(
  4016. ClientCertAuthObserver::CertificateResponse::
  4017. CANCEL_CERTIFICATE_SELECTION);
  4018. ResourceRequest request =
  4019. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  4020. base::RunLoop delete_run_loop;
  4021. mojo::PendingRemote<mojom::URLLoader> loader;
  4022. context().mutable_factory_params().process_id = kProcessId;
  4023. context().mutable_factory_params().is_corb_enabled = false;
  4024. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4025. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4026. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  4027. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4028. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4029. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4030. mojo::NullRemote() /* cookie_observer */,
  4031. client_cert_observer.Bind() /* url_loader_network_observer */,
  4032. /*devtools_observer=*/mojo::NullRemote(),
  4033. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4034. /*third_party_cookies_enabled=*/true);
  4035. RunUntilIdle();
  4036. ASSERT_TRUE(url_loader);
  4037. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4038. client()->RunUntilComplete();
  4039. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4040. EXPECT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
  4041. client()->completion_status().error_code);
  4042. }
  4043. TEST_F(URLLoaderTest, ClientAuthNoCertificate) {
  4044. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4045. net::SSLServerConfig ssl_config;
  4046. ssl_config.client_cert_type =
  4047. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  4048. // TLS 1.3 client auth errors show up post-handshake, resulting in a read
  4049. // error which on Windows causes the socket to shutdown immediately before the
  4050. // error is read.
  4051. // TODO(crbug.com/906668): Add support for testing this in TLS 1.3.
  4052. ssl_config.version_max = net::SSL_PROTOCOL_VERSION_TLS1_2;
  4053. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4054. test_server.AddDefaultHandlers(
  4055. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4056. ASSERT_TRUE(test_server.Start());
  4057. ClientCertAuthObserver client_cert_observer;
  4058. client_cert_observer.set_certificate_response(
  4059. ClientCertAuthObserver::CertificateResponse::NULL_CERTIFICATE);
  4060. ResourceRequest request =
  4061. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  4062. base::RunLoop delete_run_loop;
  4063. mojo::PendingRemote<mojom::URLLoader> loader;
  4064. context().mutable_factory_params().process_id = kProcessId;
  4065. context().mutable_factory_params().is_corb_enabled = false;
  4066. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4067. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4068. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  4069. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4070. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4071. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4072. mojo::NullRemote() /* cookie_observer */,
  4073. client_cert_observer.Bind() /* url_loader_network_observer */,
  4074. /*devtools_observer=*/mojo::NullRemote(),
  4075. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4076. /*third_party_cookies_enabled=*/true);
  4077. RunUntilIdle();
  4078. ASSERT_TRUE(url_loader);
  4079. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4080. client()->RunUntilComplete();
  4081. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4082. EXPECT_EQ(net::ERR_BAD_SSL_CLIENT_AUTH_CERT,
  4083. client()->completion_status().error_code);
  4084. }
  4085. TEST_F(URLLoaderTest, ClientAuthCertificateWithValidSignature) {
  4086. std::unique_ptr<net::FakeClientCertIdentity> identity =
  4087. net::FakeClientCertIdentity::CreateFromCertAndKeyFiles(
  4088. net::GetTestCertsDirectory(), "client_1.pem", "client_1.pk8");
  4089. ASSERT_TRUE(identity);
  4090. scoped_refptr<TestSSLPrivateKey> private_key =
  4091. base::MakeRefCounted<TestSSLPrivateKey>(identity->ssl_private_key());
  4092. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4093. net::SSLServerConfig ssl_config;
  4094. ssl_config.client_cert_type =
  4095. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  4096. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4097. test_server.AddDefaultHandlers(
  4098. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4099. ASSERT_TRUE(test_server.Start());
  4100. ClientCertAuthObserver client_cert_observer;
  4101. client_cert_observer.set_certificate_response(
  4102. ClientCertAuthObserver::CertificateResponse::VALID_CERTIFICATE_SIGNATURE);
  4103. client_cert_observer.set_private_key(private_key);
  4104. scoped_refptr<net::X509Certificate> certificate =
  4105. test_server.GetCertificate();
  4106. client_cert_observer.set_certificate(std::move(certificate));
  4107. ResourceRequest request =
  4108. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  4109. base::RunLoop delete_run_loop;
  4110. mojo::PendingRemote<mojom::URLLoader> loader;
  4111. context().mutable_factory_params().process_id = kProcessId;
  4112. context().mutable_factory_params().is_corb_enabled = false;
  4113. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4114. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4115. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  4116. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4117. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4118. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4119. mojo::NullRemote() /* cookie_observer */,
  4120. client_cert_observer.Bind() /* url_loader_network_observer */,
  4121. /*devtools_observer=*/mojo::NullRemote(),
  4122. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4123. /*third_party_cookies_enabled=*/true);
  4124. RunUntilIdle();
  4125. ASSERT_TRUE(url_loader);
  4126. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4127. EXPECT_EQ(0, private_key->sign_count());
  4128. client()->RunUntilComplete();
  4129. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4130. // The private key should have been used.
  4131. EXPECT_EQ(1, private_key->sign_count());
  4132. }
  4133. TEST_F(URLLoaderTest, ClientAuthCertificateWithInvalidSignature) {
  4134. std::unique_ptr<net::FakeClientCertIdentity> identity =
  4135. net::FakeClientCertIdentity::CreateFromCertAndKeyFiles(
  4136. net::GetTestCertsDirectory(), "client_1.pem", "client_1.pk8");
  4137. ASSERT_TRUE(identity);
  4138. scoped_refptr<TestSSLPrivateKey> private_key =
  4139. base::MakeRefCounted<TestSSLPrivateKey>(identity->ssl_private_key());
  4140. private_key->set_fail_signing(true);
  4141. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4142. net::SSLServerConfig ssl_config;
  4143. ssl_config.client_cert_type =
  4144. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  4145. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4146. test_server.AddDefaultHandlers(
  4147. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4148. ASSERT_TRUE(test_server.Start());
  4149. ClientCertAuthObserver client_cert_observer;
  4150. client_cert_observer.set_certificate_response(
  4151. ClientCertAuthObserver::CertificateResponse::VALID_CERTIFICATE_SIGNATURE);
  4152. client_cert_observer.set_private_key(private_key);
  4153. scoped_refptr<net::X509Certificate> certificate =
  4154. test_server.GetCertificate();
  4155. client_cert_observer.set_certificate(std::move(certificate));
  4156. ResourceRequest request =
  4157. CreateResourceRequest("GET", test_server.GetURL("/defaultresponse"));
  4158. base::RunLoop delete_run_loop;
  4159. mojo::PendingRemote<mojom::URLLoader> loader;
  4160. context().mutable_factory_params().process_id = kProcessId;
  4161. context().mutable_factory_params().is_corb_enabled = false;
  4162. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4163. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4164. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  4165. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4166. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4167. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4168. mojo::NullRemote() /* cookie_observer */,
  4169. client_cert_observer.Bind() /* url_loader_network_observer */,
  4170. /*devtools_observer=*/mojo::NullRemote(),
  4171. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4172. /*third_party_cookies_enabled=*/true);
  4173. RunUntilIdle();
  4174. ASSERT_TRUE(url_loader);
  4175. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4176. EXPECT_EQ(0, private_key->sign_count());
  4177. client()->RunUntilComplete();
  4178. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4179. // The private key should have been used.
  4180. EXPECT_EQ(1, private_key->sign_count());
  4181. EXPECT_EQ(net::ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED,
  4182. client()->completion_status().error_code);
  4183. }
  4184. TEST_F(URLLoaderTest, BlockAllCookies) {
  4185. GURL first_party_url("http://www.example.com.test/");
  4186. net::SiteForCookies site_for_cookies =
  4187. net::SiteForCookies::FromUrl(first_party_url);
  4188. GURL third_party_url("http://www.some.other.origin.test/");
  4189. ResourceRequest request = CreateResourceRequest("GET", first_party_url);
  4190. base::RunLoop delete_run_loop;
  4191. mojo::PendingRemote<mojom::URLLoader> loader;
  4192. context().mutable_factory_params().process_id = kProcessId;
  4193. context().mutable_factory_params().is_corb_enabled = false;
  4194. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4195. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4196. loader.InitWithNewPipeAndPassReceiver(),
  4197. mojom::kURLLoadOptionBlockAllCookies, request, client()->CreateRemote(),
  4198. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4199. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4200. nullptr /* trust_token_helper */,
  4201. mojo::NullRemote() /* cookie_observer */,
  4202. mojo::NullRemote() /* url_loader_network_observer */,
  4203. /*devtools_observer=*/mojo::NullRemote(),
  4204. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4205. /*third_party_cookies_enabled=*/true);
  4206. EXPECT_FALSE(url_loader->AllowCookies(first_party_url, site_for_cookies));
  4207. EXPECT_FALSE(url_loader->AllowCookies(third_party_url, site_for_cookies));
  4208. }
  4209. TEST_F(URLLoaderTest, BlockOnlyThirdPartyCookies) {
  4210. GURL first_party_url("http://www.example.com.test/");
  4211. net::SiteForCookies site_for_cookies =
  4212. net::SiteForCookies::FromUrl(first_party_url);
  4213. GURL third_party_url("http://www.some.other.origin.test/");
  4214. ResourceRequest request = CreateResourceRequest("GET", first_party_url);
  4215. base::RunLoop delete_run_loop;
  4216. mojo::PendingRemote<mojom::URLLoader> loader;
  4217. context().mutable_factory_params().process_id = kProcessId;
  4218. context().mutable_factory_params().is_corb_enabled = false;
  4219. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4220. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4221. loader.InitWithNewPipeAndPassReceiver(),
  4222. mojom::kURLLoadOptionBlockThirdPartyCookies, request,
  4223. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4224. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4225. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4226. mojo::NullRemote() /* cookie_observer */,
  4227. mojo::NullRemote() /* url_loader_network_observer */,
  4228. /*devtools_observer=*/mojo::NullRemote(),
  4229. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4230. /*third_party_cookies_enabled=*/true);
  4231. EXPECT_TRUE(url_loader->AllowCookies(first_party_url, site_for_cookies));
  4232. EXPECT_FALSE(url_loader->AllowCookies(third_party_url, site_for_cookies));
  4233. }
  4234. TEST_F(URLLoaderTest, AllowAllCookies) {
  4235. GURL first_party_url("http://www.example.com.test/");
  4236. net::SiteForCookies site_for_cookies =
  4237. net::SiteForCookies::FromUrl(first_party_url);
  4238. GURL third_party_url("http://www.some.other.origin.test/");
  4239. ResourceRequest request = CreateResourceRequest("GET", first_party_url);
  4240. base::RunLoop delete_run_loop;
  4241. mojo::PendingRemote<mojom::URLLoader> loader;
  4242. context().mutable_factory_params().process_id = kProcessId;
  4243. context().mutable_factory_params().is_corb_enabled = false;
  4244. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4245. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4246. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4247. request, client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4248. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4249. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4250. mojo::NullRemote() /* cookie_observer */,
  4251. mojo::NullRemote() /* url_loader_network_observer */,
  4252. /*devtools_observer=*/mojo::NullRemote(),
  4253. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4254. /*third_party_cookies_enabled=*/true);
  4255. EXPECT_TRUE(url_loader->AllowCookies(first_party_url, site_for_cookies));
  4256. EXPECT_TRUE(url_loader->AllowCookies(third_party_url, site_for_cookies));
  4257. }
  4258. namespace {
  4259. enum class TestMode {
  4260. kCredentialsModeOmit,
  4261. kCredentialsModeOmitWorkaround,
  4262. kCredentialsModeOmitWithFeatureFix,
  4263. };
  4264. } // namespace
  4265. class URLLoaderParameterTest : public URLLoaderTest,
  4266. public ::testing::WithParamInterface<TestMode> {
  4267. public:
  4268. ~URLLoaderParameterTest() override = default;
  4269. private:
  4270. void SetUp() override {
  4271. URLLoaderTest::SetUp();
  4272. if (GetParam() == TestMode::kCredentialsModeOmitWithFeatureFix) {
  4273. scoped_feature_list.InitAndEnableFeature(features::kOmitCorsClientCert);
  4274. } else {
  4275. scoped_feature_list.InitAndDisableFeature(features::kOmitCorsClientCert);
  4276. }
  4277. }
  4278. base::test::ScopedFeatureList scoped_feature_list;
  4279. };
  4280. INSTANTIATE_TEST_SUITE_P(
  4281. All,
  4282. URLLoaderParameterTest,
  4283. testing::Values(TestMode::kCredentialsModeOmit,
  4284. TestMode::kCredentialsModeOmitWorkaround,
  4285. TestMode::kCredentialsModeOmitWithFeatureFix));
  4286. // Tests that a request with CredentialsMode::kOmit still sends client
  4287. // certificates when features::kOmitCorsClientCert is disabled, and when the
  4288. // feature is enabled client certificates are not sent. Also test that when
  4289. // CredentialsMode::kOmitBug_775438_Workaround is used client certificates are
  4290. // not sent as well. This should be removed when crbug.com/775438 is fixed.
  4291. TEST_P(URLLoaderParameterTest, CredentialsModeOmitRequireClientCert) {
  4292. // Set up a server that requires certificates.
  4293. net::SSLServerConfig ssl_config;
  4294. ssl_config.client_cert_type =
  4295. net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  4296. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4297. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4298. test_server.AddDefaultHandlers(
  4299. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4300. ASSERT_TRUE(test_server.Start());
  4301. // Make sure the client has valid certificates.
  4302. std::unique_ptr<net::FakeClientCertIdentity> identity =
  4303. net::FakeClientCertIdentity::CreateFromCertAndKeyFiles(
  4304. net::GetTestCertsDirectory(), "client_1.pem", "client_1.pk8");
  4305. ASSERT_TRUE(identity);
  4306. scoped_refptr<TestSSLPrivateKey> private_key =
  4307. base::MakeRefCounted<TestSSLPrivateKey>(identity->ssl_private_key());
  4308. ClientCertAuthObserver client_cert_observer;
  4309. client_cert_observer.set_certificate_response(
  4310. ClientCertAuthObserver::CertificateResponse::VALID_CERTIFICATE_SIGNATURE);
  4311. client_cert_observer.set_private_key(private_key);
  4312. client_cert_observer.set_certificate(identity->certificate());
  4313. ResourceRequest request =
  4314. CreateResourceRequest("GET", test_server.GetURL("/simple_page.html"));
  4315. if (GetParam() == TestMode::kCredentialsModeOmitWorkaround) {
  4316. request.credentials_mode =
  4317. mojom::CredentialsMode::kOmitBug_775438_Workaround;
  4318. } else {
  4319. request.credentials_mode = mojom::CredentialsMode::kOmit;
  4320. }
  4321. base::RunLoop delete_run_loop;
  4322. mojo::Remote<mojom::URLLoader> loader;
  4323. std::unique_ptr<URLLoader> url_loader;
  4324. context().mutable_factory_params().process_id = kProcessId;
  4325. context().mutable_factory_params().is_corb_enabled = false;
  4326. url_loader = std::make_unique<URLLoader>(
  4327. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4328. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  4329. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4330. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4331. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4332. mojo::NullRemote() /* cookie_observer */,
  4333. client_cert_observer.Bind() /* url_loader_network_observer */,
  4334. /*devtools_observer=*/mojo::NullRemote(),
  4335. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4336. /*third_party_cookies_enabled=*/true);
  4337. client()->RunUntilComplete();
  4338. delete_run_loop.Run();
  4339. if (GetParam() == TestMode::kCredentialsModeOmitWithFeatureFix ||
  4340. GetParam() == TestMode::kCredentialsModeOmitWorkaround) {
  4341. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4342. EXPECT_NE(net::OK, client()->completion_status().error_code);
  4343. } else {
  4344. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4345. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  4346. }
  4347. }
  4348. // Tests that a request with CredentialsMode::kOmitBug_775438_Workaround, and
  4349. // CredentialsMode::kOmit when features::kOmitCorsClientCert is enabled doesn't
  4350. // send client certificates with a server that optionally requires certificates.
  4351. TEST_P(URLLoaderParameterTest, CredentialsModeOmitOptionalClientCert) {
  4352. // Set up a server that requires certificates.
  4353. net::SSLServerConfig ssl_config;
  4354. ssl_config.client_cert_type =
  4355. net::SSLServerConfig::ClientCertType::OPTIONAL_CLIENT_CERT;
  4356. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  4357. test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
  4358. test_server.AddDefaultHandlers(
  4359. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  4360. ASSERT_TRUE(test_server.Start());
  4361. // Make sure the client has valid certificates.
  4362. std::unique_ptr<net::FakeClientCertIdentity> identity =
  4363. net::FakeClientCertIdentity::CreateFromCertAndKeyFiles(
  4364. net::GetTestCertsDirectory(), "client_1.pem", "client_1.pk8");
  4365. ASSERT_TRUE(identity);
  4366. scoped_refptr<TestSSLPrivateKey> private_key =
  4367. base::MakeRefCounted<TestSSLPrivateKey>(identity->ssl_private_key());
  4368. ClientCertAuthObserver client_cert_observer;
  4369. client_cert_observer.set_certificate_response(
  4370. ClientCertAuthObserver::CertificateResponse::VALID_CERTIFICATE_SIGNATURE);
  4371. client_cert_observer.set_private_key(private_key);
  4372. client_cert_observer.set_certificate(identity->certificate());
  4373. ResourceRequest request =
  4374. CreateResourceRequest("GET", test_server.GetURL("/simple_page.html"));
  4375. if (GetParam() == TestMode::kCredentialsModeOmitWorkaround) {
  4376. request.credentials_mode =
  4377. mojom::CredentialsMode::kOmitBug_775438_Workaround;
  4378. } else {
  4379. request.credentials_mode = mojom::CredentialsMode::kOmit;
  4380. }
  4381. base::RunLoop delete_run_loop;
  4382. mojo::Remote<mojom::URLLoader> loader;
  4383. std::unique_ptr<URLLoader> url_loader;
  4384. context().mutable_factory_params().process_id = kProcessId;
  4385. context().mutable_factory_params().is_corb_enabled = false;
  4386. url_loader = std::make_unique<URLLoader>(
  4387. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4388. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  4389. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  4390. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4391. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4392. mojo::NullRemote() /* cookie_observer */,
  4393. client_cert_observer.Bind() /* url_loader_network_observer */,
  4394. /*devtools_observer=*/mojo::NullRemote(),
  4395. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4396. /*third_party_cookies_enabled=*/true);
  4397. client()->RunUntilComplete();
  4398. delete_run_loop.Run();
  4399. if (GetParam() == TestMode::kCredentialsModeOmitWithFeatureFix ||
  4400. GetParam() == TestMode::kCredentialsModeOmitWorkaround) {
  4401. EXPECT_EQ(0, client_cert_observer.on_certificate_requested_counter());
  4402. } else {
  4403. EXPECT_EQ(1, client_cert_observer.on_certificate_requested_counter());
  4404. }
  4405. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  4406. }
  4407. #endif // !BUILDFLAG(IS_IOS)
  4408. TEST_F(URLLoaderTest, CookieReporting) {
  4409. {
  4410. TestURLLoaderClient loader_client;
  4411. ResourceRequest request =
  4412. CreateResourceRequest("GET", test_server()->GetURL("/set-cookie?a=b"));
  4413. MockCookieObserver cookie_observer;
  4414. base::RunLoop delete_run_loop;
  4415. mojo::PendingRemote<mojom::URLLoader> loader;
  4416. context().mutable_factory_params().process_id = kProcessId;
  4417. context().mutable_factory_params().is_corb_enabled = false;
  4418. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4419. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4420. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4421. request, loader_client.CreateRemote(),
  4422. nullptr /* sync_url_loader_client */,
  4423. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4424. 0 /* keepalive_request_size */, nullptr,
  4425. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  4426. mojo::NullRemote() /* url_loader_network_observer */,
  4427. /*devtools_observer=*/mojo::NullRemote(),
  4428. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4429. /*third_party_cookies_enabled=*/true);
  4430. delete_run_loop.Run();
  4431. loader_client.RunUntilComplete();
  4432. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4433. cookie_observer.WaitForCookies(1u);
  4434. EXPECT_THAT(
  4435. cookie_observer.observed_cookies(),
  4436. testing::ElementsAre(MatchesCookieDetails(
  4437. CookieAccessType::kChange,
  4438. CookieOrLine("a=b", mojom::CookieOrLine::Tag::kCookie), true)));
  4439. }
  4440. {
  4441. TestURLLoaderClient loader_client;
  4442. ResourceRequest request =
  4443. CreateResourceRequest("GET", test_server()->GetURL("/nocontent"));
  4444. MockCookieObserver cookie_observer;
  4445. base::RunLoop delete_run_loop;
  4446. mojo::PendingRemote<mojom::URLLoader> loader;
  4447. context().mutable_factory_params().process_id = kProcessId;
  4448. context().mutable_factory_params().is_corb_enabled = false;
  4449. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4450. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4451. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4452. request, loader_client.CreateRemote(),
  4453. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4454. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4455. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  4456. mojo::NullRemote() /* url_loader_network_observer */,
  4457. /*devtools_observer=*/mojo::NullRemote(),
  4458. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4459. /*third_party_cookies_enabled=*/true);
  4460. delete_run_loop.Run();
  4461. loader_client.RunUntilComplete();
  4462. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4463. cookie_observer.WaitForCookies(1u);
  4464. EXPECT_THAT(
  4465. cookie_observer.observed_cookies(),
  4466. testing::ElementsAre(MatchesCookieDetails(
  4467. CookieAccessType::kRead,
  4468. CookieOrLine("a=b", mojom::CookieOrLine::Tag::kCookie), true)));
  4469. }
  4470. {
  4471. TestURLLoaderClient loader_client;
  4472. ResourceRequest request = CreateResourceRequest(
  4473. "GET", test_server()->GetURL("/set-cookie?invalid=foo;SameParty"));
  4474. MockCookieObserver cookie_observer;
  4475. base::RunLoop delete_run_loop;
  4476. mojo::PendingRemote<mojom::URLLoader> loader;
  4477. context().mutable_factory_params().process_id = kProcessId;
  4478. context().mutable_factory_params().is_corb_enabled = false;
  4479. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4480. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4481. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4482. request, loader_client.CreateRemote(),
  4483. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4484. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4485. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  4486. mojo::NullRemote() /* url_loader_network_observer */,
  4487. /*devtools_observer=*/mojo::NullRemote(),
  4488. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4489. /*third_party_cookies_enabled=*/true);
  4490. delete_run_loop.Run();
  4491. loader_client.RunUntilComplete();
  4492. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4493. cookie_observer.WaitForCookies(2u);
  4494. EXPECT_THAT(
  4495. cookie_observer.observed_cookies(),
  4496. testing::ElementsAre(
  4497. MatchesCookieDetails(
  4498. CookieAccessType::kRead,
  4499. CookieOrLine("a=b", mojom::CookieOrLine::Tag::kCookie), true),
  4500. MatchesCookieDetails(
  4501. CookieAccessType::kChange,
  4502. CookieOrLine("invalid=foo;SameParty",
  4503. mojom::CookieOrLine::Tag::kCookieString),
  4504. false)));
  4505. }
  4506. }
  4507. TEST_F(URLLoaderTest, CookieReportingRedirect) {
  4508. MockCookieObserver cookie_observer(CookieAccessType::kChange);
  4509. GURL dest_url = test_server()->GetURL("/nocontent");
  4510. GURL redirecting_url =
  4511. test_server()->GetURL("/server-redirect-with-cookie?" + dest_url.spec());
  4512. TestURLLoaderClient loader_client;
  4513. ResourceRequest request = CreateResourceRequest("GET", redirecting_url);
  4514. base::RunLoop delete_run_loop;
  4515. mojo::Remote<mojom::URLLoader> loader;
  4516. context().mutable_factory_params().process_id = kProcessId;
  4517. context().mutable_factory_params().is_corb_enabled = false;
  4518. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4519. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4520. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  4521. loader_client.CreateRemote(), nullptr /* sync_url_loader_client */,
  4522. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4523. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  4524. cookie_observer.GetRemote(),
  4525. mojo::NullRemote() /* url_loader_network_observer */,
  4526. /*devtools_observer=*/mojo::NullRemote(),
  4527. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4528. /*third_party_cookies_enabled=*/true);
  4529. loader_client.RunUntilRedirectReceived();
  4530. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  4531. loader_client.RunUntilComplete();
  4532. delete_run_loop.Run();
  4533. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4534. cookie_observer.WaitForCookies(1u);
  4535. EXPECT_THAT(cookie_observer.observed_cookies(),
  4536. testing::ElementsAre(MatchesCookieDetails(
  4537. CookieAccessType::kChange,
  4538. CookieOrLine("server-redirect=true",
  4539. mojom::CookieOrLine::Tag::kCookie),
  4540. true)));
  4541. // Make sure that this has the pre-redirect URL, not the post-redirect one.
  4542. EXPECT_EQ(redirecting_url, cookie_observer.observed_cookies()[0].url);
  4543. }
  4544. TEST_F(URLLoaderTest, CookieReportingAuth) {
  4545. for (auto mode :
  4546. {ClientCertAuthObserver::CredentialsResponse::NO_CREDENTIALS,
  4547. ClientCertAuthObserver::CredentialsResponse::CORRECT_CREDENTIALS}) {
  4548. MockCookieObserver cookie_observer(CookieAccessType::kChange);
  4549. ClientCertAuthObserver client_auth_observer;
  4550. client_auth_observer.set_credentials_response(mode);
  4551. GURL url = test_server()->GetURL(
  4552. "/auth-basic?set-cookie-if-challenged&password=PASS");
  4553. TestURLLoaderClient loader_client;
  4554. ResourceRequest request = CreateResourceRequest("GET", url);
  4555. base::RunLoop delete_run_loop;
  4556. mojo::PendingRemote<mojom::URLLoader> loader;
  4557. context().mutable_factory_params().process_id = kProcessId;
  4558. context().mutable_factory_params().is_corb_enabled = false;
  4559. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4560. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4561. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4562. request, loader_client.CreateRemote(),
  4563. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4564. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4565. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  4566. client_auth_observer.Bind() /* url_loader_network_observer */,
  4567. /*devtools_observer=*/mojo::NullRemote(),
  4568. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4569. /*third_party_cookies_enabled=*/true);
  4570. loader_client.RunUntilComplete();
  4571. delete_run_loop.Run();
  4572. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4573. cookie_observer.WaitForCookies(1u);
  4574. EXPECT_THAT(cookie_observer.observed_cookies(),
  4575. testing::ElementsAre(MatchesCookieDetails(
  4576. CookieAccessType::kChange,
  4577. CookieOrLine("got_challenged=true",
  4578. mojom::CookieOrLine::Tag::kCookie),
  4579. true)));
  4580. }
  4581. }
  4582. TEST_F(URLLoaderTest, RawRequestCookies) {
  4583. {
  4584. MockDevToolsObserver devtools_observer;
  4585. TestURLLoaderClient loader_client;
  4586. ResourceRequest request = CreateResourceRequest(
  4587. "GET", test_server()->GetURL("/echoheader?cookie"));
  4588. // Set the devtools id to trigger the RawResponse call
  4589. request.devtools_request_id = "TEST";
  4590. GURL cookie_url = test_server()->GetURL("/");
  4591. auto cookie = net::CanonicalCookie::Create(
  4592. cookie_url, "a=b", base::Time::Now(), absl::nullopt /* server_time */,
  4593. absl::nullopt /* cookie_partition_key */);
  4594. url_request_context()->cookie_store()->SetCanonicalCookieAsync(
  4595. std::move(cookie), cookie_url, net::CookieOptions::MakeAllInclusive(),
  4596. base::DoNothing());
  4597. base::RunLoop delete_run_loop;
  4598. mojo::PendingRemote<mojom::URLLoader> loader;
  4599. context().mutable_factory_params().process_id = kProcessId;
  4600. context().mutable_factory_params().is_corb_enabled = false;
  4601. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4602. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4603. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4604. request, loader_client.CreateRemote(),
  4605. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4606. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4607. nullptr /* trust_token_helper */,
  4608. mojo::NullRemote() /* cookie_observer */,
  4609. mojo::NullRemote() /* url_loader_network_observer */,
  4610. devtools_observer.Bind(),
  4611. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4612. /*third_party_cookies_enabled=*/true);
  4613. delete_run_loop.Run();
  4614. loader_client.RunUntilComplete();
  4615. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4616. devtools_observer.WaitUntilRawRequest(1u);
  4617. EXPECT_EQ(200, devtools_observer.raw_response_http_status_code());
  4618. EXPECT_EQ("a", devtools_observer.raw_request_cookies()[0].cookie.Name());
  4619. EXPECT_EQ("b", devtools_observer.raw_request_cookies()[0].cookie.Value());
  4620. EXPECT_TRUE(devtools_observer.raw_request_cookies()[0]
  4621. .access_result.status.IsInclude());
  4622. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4623. }
  4624. }
  4625. TEST_F(URLLoaderTest, RawRequestCookiesFlagged) {
  4626. {
  4627. MockDevToolsObserver devtools_observer;
  4628. TestURLLoaderClient loader_client;
  4629. ResourceRequest request = CreateResourceRequest(
  4630. "GET", test_server()->GetURL("/echoheader?cookie"));
  4631. // Set the devtools id to trigger the RawResponse call
  4632. request.devtools_request_id = "TEST";
  4633. // Set the path to an irrelevant url to block the cookie from sending
  4634. GURL cookie_url = test_server()->GetURL("/");
  4635. auto cookie = net::CanonicalCookie::Create(
  4636. cookie_url, "a=b;Path=/something-else", base::Time::Now(),
  4637. absl::nullopt /* server_time */,
  4638. absl::nullopt /* cookie_partition_key */);
  4639. url_request_context()->cookie_store()->SetCanonicalCookieAsync(
  4640. std::move(cookie), cookie_url, net::CookieOptions::MakeAllInclusive(),
  4641. base::DoNothing());
  4642. base::RunLoop delete_run_loop;
  4643. mojo::PendingRemote<mojom::URLLoader> loader;
  4644. context().mutable_factory_params().process_id = kProcessId;
  4645. context().mutable_factory_params().is_corb_enabled = false;
  4646. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4647. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4648. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4649. request, loader_client.CreateRemote(),
  4650. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4651. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4652. nullptr /* trust_token_helper */,
  4653. mojo::NullRemote() /* cookie_observer */,
  4654. mojo::NullRemote() /* url_loader_network_observer */,
  4655. devtools_observer.Bind(),
  4656. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4657. /*third_party_cookies_enabled=*/true);
  4658. delete_run_loop.Run();
  4659. loader_client.RunUntilComplete();
  4660. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4661. devtools_observer.WaitUntilRawRequest(1u);
  4662. EXPECT_EQ(200, devtools_observer.raw_response_http_status_code());
  4663. EXPECT_EQ("a", devtools_observer.raw_request_cookies()[0].cookie.Name());
  4664. EXPECT_EQ("b", devtools_observer.raw_request_cookies()[0].cookie.Value());
  4665. EXPECT_TRUE(devtools_observer.raw_request_cookies()[0]
  4666. .access_result.status.HasExactlyExclusionReasonsForTesting(
  4667. {net::CookieInclusionStatus::EXCLUDE_NOT_ON_PATH}));
  4668. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4669. }
  4670. }
  4671. TEST_F(URLLoaderTest, RawResponseCookies) {
  4672. {
  4673. MockDevToolsObserver devtools_observer;
  4674. TestURLLoaderClient loader_client;
  4675. ResourceRequest request =
  4676. CreateResourceRequest("GET", test_server()->GetURL("/set-cookie?a=b"));
  4677. // Set the devtools id to trigger the RawResponse call
  4678. request.devtools_request_id = "TEST";
  4679. base::RunLoop delete_run_loop;
  4680. mojo::PendingRemote<mojom::URLLoader> loader;
  4681. context().mutable_factory_params().process_id = kProcessId;
  4682. context().mutable_factory_params().is_corb_enabled = false;
  4683. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4684. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4685. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4686. request, loader_client.CreateRemote(),
  4687. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4688. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4689. nullptr /* trust_token_helper */,
  4690. mojo::NullRemote() /* cookie_observer */,
  4691. mojo::NullRemote() /* url_loader_network_observer */,
  4692. devtools_observer.Bind(),
  4693. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4694. /*third_party_cookies_enabled=*/true);
  4695. delete_run_loop.Run();
  4696. loader_client.RunUntilComplete();
  4697. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4698. devtools_observer.WaitUntilRawResponse(1u);
  4699. EXPECT_EQ(200, devtools_observer.raw_response_http_status_code());
  4700. EXPECT_EQ("a", devtools_observer.raw_response_cookies()[0].cookie->Name());
  4701. EXPECT_EQ("b", devtools_observer.raw_response_cookies()[0].cookie->Value());
  4702. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0]
  4703. .access_result.status.IsInclude());
  4704. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4705. ASSERT_TRUE(devtools_observer.raw_response_headers());
  4706. EXPECT_NE(devtools_observer.raw_response_headers()->find("Set-Cookie: a=b"),
  4707. std::string::npos);
  4708. }
  4709. }
  4710. TEST_F(URLLoaderTest, RawResponseCookiesInvalid) {
  4711. {
  4712. MockDevToolsObserver devtools_observer;
  4713. TestURLLoaderClient loader_client;
  4714. ResourceRequest request = CreateResourceRequest(
  4715. "GET", test_server()->GetURL("/set-invalid-cookie"));
  4716. // Set the devtools id to trigger the RawResponse call
  4717. request.devtools_request_id = "TEST";
  4718. base::RunLoop delete_run_loop;
  4719. mojo::PendingRemote<mojom::URLLoader> loader;
  4720. context().mutable_factory_params().process_id = kProcessId;
  4721. context().mutable_factory_params().is_corb_enabled = false;
  4722. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4723. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4724. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4725. request, loader_client.CreateRemote(),
  4726. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4727. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4728. nullptr /* trust_token_helper */,
  4729. mojo::NullRemote() /* cookie_observer */,
  4730. mojo::NullRemote() /* url_loader_network_observer */,
  4731. devtools_observer.Bind(),
  4732. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4733. /*third_party_cookies_enabled=*/true);
  4734. delete_run_loop.Run();
  4735. loader_client.RunUntilComplete();
  4736. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4737. devtools_observer.WaitUntilRawResponse(1u);
  4738. EXPECT_EQ(200, devtools_observer.raw_response_http_status_code());
  4739. // On these failures the cookie object is not created
  4740. EXPECT_FALSE(devtools_observer.raw_response_cookies()[0].cookie);
  4741. EXPECT_TRUE(
  4742. devtools_observer.raw_response_cookies()[0]
  4743. .access_result.status.HasExactlyExclusionReasonsForTesting(
  4744. {net::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE}));
  4745. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4746. }
  4747. }
  4748. TEST_F(URLLoaderTest, RawResponseCookiesRedirect) {
  4749. // Check a valid cookie
  4750. {
  4751. MockDevToolsObserver devtools_observer;
  4752. GURL dest_url = test_server()->GetURL("a.test", "/nocontent");
  4753. GURL redirecting_url = test_server()->GetURL(
  4754. "a.test", "/server-redirect-with-cookie?" + dest_url.spec());
  4755. TestURLLoaderClient loader_client;
  4756. ResourceRequest request = CreateResourceRequest("GET", redirecting_url);
  4757. // Set the devtools id to trigger the RawResponse call
  4758. request.devtools_request_id = "TEST";
  4759. base::RunLoop delete_run_loop;
  4760. mojo::Remote<mojom::URLLoader> loader;
  4761. context().mutable_factory_params().process_id = kProcessId;
  4762. context().mutable_factory_params().is_corb_enabled = false;
  4763. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4764. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4765. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  4766. loader_client.CreateRemote(), nullptr /* sync_url_loader_client */,
  4767. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4768. 0 /* keepalive_request_size */, nullptr,
  4769. nullptr /* trust_token_helper */,
  4770. mojo::NullRemote() /* cookie_observer */,
  4771. mojo::NullRemote() /* url_loader_network_observer */,
  4772. devtools_observer.Bind(),
  4773. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4774. /*third_party_cookies_enabled=*/true);
  4775. loader_client.RunUntilRedirectReceived();
  4776. ASSERT_TRUE(devtools_observer.raw_response_headers());
  4777. EXPECT_NE(devtools_observer.raw_response_headers()->find(
  4778. "Set-Cookie: server-redirect=true"),
  4779. std::string::npos);
  4780. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  4781. loader_client.RunUntilComplete();
  4782. delete_run_loop.Run();
  4783. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4784. devtools_observer.WaitUntilRawResponse(1u);
  4785. EXPECT_EQ(204, devtools_observer.raw_response_http_status_code());
  4786. EXPECT_EQ("server-redirect",
  4787. devtools_observer.raw_response_cookies()[0].cookie->Name());
  4788. EXPECT_EQ("true",
  4789. devtools_observer.raw_response_cookies()[0].cookie->Value());
  4790. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0]
  4791. .access_result.status.IsInclude());
  4792. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4793. }
  4794. // Check a flagged cookie (secure cookie over an insecure connection)
  4795. {
  4796. GURL dest_url = test_server()->GetURL("a.test", "/nocontent");
  4797. GURL redirecting_url = test_server()->GetURL(
  4798. "a.test", "/server-redirect-with-secure-cookie?" + dest_url.spec());
  4799. MockDevToolsObserver devtools_observer;
  4800. TestURLLoaderClient loader_client;
  4801. ResourceRequest request = CreateResourceRequest("GET", redirecting_url);
  4802. // Set the devtools id to trigger the RawResponse call
  4803. request.devtools_request_id = "TEST";
  4804. base::RunLoop delete_run_loop;
  4805. mojo::Remote<mojom::URLLoader> loader;
  4806. context().mutable_factory_params().process_id = kProcessId;
  4807. context().mutable_factory_params().is_corb_enabled = false;
  4808. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4809. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4810. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  4811. loader_client.CreateRemote(), nullptr /* sync_url_loader_client */,
  4812. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  4813. 0 /* keepalive_request_size */, nullptr,
  4814. nullptr /* trust_token_helper */,
  4815. mojo::NullRemote() /* cookie_observer */,
  4816. mojo::NullRemote() /* url_loader_network_observer */,
  4817. devtools_observer.Bind(),
  4818. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4819. /*third_party_cookies_enabled=*/true);
  4820. loader_client.RunUntilRedirectReceived();
  4821. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  4822. loader_client.RunUntilComplete();
  4823. delete_run_loop.Run();
  4824. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4825. devtools_observer.WaitUntilRawResponse(1u);
  4826. EXPECT_EQ(204, devtools_observer.raw_response_http_status_code());
  4827. // On these failures the cookie object is created but not included.
  4828. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0].cookie->IsSecure());
  4829. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0]
  4830. .access_result.status.HasExactlyExclusionReasonsForTesting(
  4831. {net::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
  4832. }
  4833. }
  4834. TEST_F(URLLoaderTest, RawResponseCookiesAuth) {
  4835. // Check a valid cookie
  4836. {
  4837. MockDevToolsObserver devtools_observer;
  4838. ClientCertAuthObserver client_auth_observer;
  4839. client_auth_observer.set_credentials_response(
  4840. ClientCertAuthObserver::CredentialsResponse::NO_CREDENTIALS);
  4841. GURL url = test_server()->GetURL(
  4842. "a.test", "/auth-basic?set-cookie-if-challenged&password=PASS");
  4843. TestURLLoaderClient loader_client;
  4844. ResourceRequest request = CreateResourceRequest("GET", url);
  4845. // Set the devtools id to trigger the RawResponse call
  4846. request.devtools_request_id = "TEST";
  4847. base::RunLoop delete_run_loop;
  4848. mojo::PendingRemote<mojom::URLLoader> loader;
  4849. context().mutable_factory_params().process_id = kProcessId;
  4850. context().mutable_factory_params().is_corb_enabled = false;
  4851. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4852. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4853. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4854. request, loader_client.CreateRemote(),
  4855. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4856. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4857. nullptr /* trust_token_helper */,
  4858. mojo::NullRemote() /* cookie_observer */,
  4859. mojo::NullRemote() /* url_loader_network_observer */,
  4860. devtools_observer.Bind(),
  4861. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4862. /*third_party_cookies_enabled=*/true);
  4863. loader_client.RunUntilComplete();
  4864. delete_run_loop.Run();
  4865. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4866. devtools_observer.WaitUntilRawResponse(1u);
  4867. EXPECT_EQ(401, devtools_observer.raw_response_http_status_code());
  4868. EXPECT_EQ("got_challenged",
  4869. devtools_observer.raw_response_cookies()[0].cookie->Name());
  4870. EXPECT_EQ("true",
  4871. devtools_observer.raw_response_cookies()[0].cookie->Value());
  4872. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0]
  4873. .access_result.status.IsInclude());
  4874. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4875. }
  4876. // Check a flagged cookie (secure cookie from insecure connection)
  4877. {
  4878. MockDevToolsObserver devtools_observer;
  4879. ClientCertAuthObserver client_auth_observer;
  4880. client_auth_observer.set_credentials_response(
  4881. ClientCertAuthObserver::CredentialsResponse::NO_CREDENTIALS);
  4882. GURL url = test_server()->GetURL(
  4883. "a.test", "/auth-basic?set-secure-cookie-if-challenged&password=PASS");
  4884. TestURLLoaderClient loader_client;
  4885. ResourceRequest request = CreateResourceRequest("GET", url);
  4886. // Set the devtools id to trigger the RawResponse call
  4887. request.devtools_request_id = "TEST";
  4888. base::RunLoop delete_run_loop;
  4889. mojo::PendingRemote<mojom::URLLoader> loader;
  4890. context().mutable_factory_params().process_id = kProcessId;
  4891. context().mutable_factory_params().is_corb_enabled = false;
  4892. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4893. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4894. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4895. request, loader_client.CreateRemote(),
  4896. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4897. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4898. nullptr /* trust_token_helper */,
  4899. mojo::NullRemote() /* cookie_observer */,
  4900. mojo::NullRemote() /* url_loader_network_observer */,
  4901. devtools_observer.Bind(),
  4902. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4903. /*third_party_cookies_enabled=*/true);
  4904. loader_client.RunUntilComplete();
  4905. delete_run_loop.Run();
  4906. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  4907. EXPECT_EQ(401, devtools_observer.raw_response_http_status_code());
  4908. devtools_observer.WaitUntilRawResponse(1u);
  4909. // On these failures the cookie object is created but not included.
  4910. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0].cookie->IsSecure());
  4911. EXPECT_TRUE(devtools_observer.raw_response_cookies()[0]
  4912. .access_result.status.HasExactlyExclusionReasonsForTesting(
  4913. {net::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
  4914. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4915. }
  4916. }
  4917. TEST_F(URLLoaderTest, RawResponseQUIC) {
  4918. {
  4919. MockDevToolsObserver devtools_observer;
  4920. TestURLLoaderClient loader_client;
  4921. ResourceRequest request =
  4922. CreateResourceRequest("GET", net::QuicSimpleTestServer::GetFileURL(""));
  4923. // Set the devtools id to trigger the RawResponse call
  4924. request.devtools_request_id = "TEST";
  4925. base::RunLoop delete_run_loop;
  4926. mojo::PendingRemote<mojom::URLLoader> loader;
  4927. context().mutable_factory_params().process_id = kProcessId;
  4928. context().mutable_factory_params().is_corb_enabled = false;
  4929. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4930. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4931. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4932. request, loader_client.CreateRemote(),
  4933. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4934. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  4935. nullptr /* trust_token_helper */,
  4936. mojo::NullRemote() /* cookie_observer */,
  4937. mojo::NullRemote() /* url_loader_network_observer */,
  4938. devtools_observer.Bind(),
  4939. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4940. /*third_party_cookies_enabled=*/true);
  4941. delete_run_loop.Run();
  4942. loader_client.RunUntilComplete();
  4943. ASSERT_EQ(net::OK, loader_client.completion_status().error_code);
  4944. devtools_observer.WaitUntilRawResponse(0u);
  4945. EXPECT_EQ(404, devtools_observer.raw_response_http_status_code());
  4946. EXPECT_EQ("TEST", devtools_observer.devtools_request_id());
  4947. // QUIC responses don't have raw header text, so there shouldn't be any here
  4948. EXPECT_FALSE(devtools_observer.raw_response_headers());
  4949. }
  4950. }
  4951. TEST_F(URLLoaderTest, EarlyHints) {
  4952. const std::string kPath = "/hinted";
  4953. const std::string kResponseBody = "content with hints";
  4954. const std::string kPreloadPath = "/hello.txt";
  4955. // Prepare a response with an Early Hints response.
  4956. spdy::Http2HeaderBlock response_headers;
  4957. response_headers[":status"] = "200";
  4958. response_headers[":path"] = kPath;
  4959. std::vector<spdy::Http2HeaderBlock> early_hints;
  4960. spdy::Http2HeaderBlock hints_headers;
  4961. hints_headers["link"] =
  4962. base::StringPrintf("<%s>; rel=preload", kPreloadPath.c_str());
  4963. early_hints.push_back(std::move(hints_headers));
  4964. net::QuicSimpleTestServer::AddResponseWithEarlyHints(
  4965. kPath, response_headers, kResponseBody, early_hints);
  4966. // Create a loader and a client to request `kPath`. The client should receive
  4967. // an Early Hints which contains a preload link header.
  4968. TestURLLoaderClient loader_client;
  4969. ResourceRequest request = CreateResourceRequest(
  4970. "GET", net::QuicSimpleTestServer::GetFileURL(kPath));
  4971. base::RunLoop delete_run_loop;
  4972. mojo::PendingRemote<mojom::URLLoader> loader;
  4973. context().mutable_factory_params().process_id = kProcessId;
  4974. context().mutable_factory_params().is_corb_enabled = false;
  4975. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  4976. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  4977. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  4978. request, loader_client.CreateRemote(),
  4979. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  4980. /*request_id=*/0, /*keepalive_request_size=*/0, nullptr,
  4981. /*trust_token_helper=*/nullptr,
  4982. /*cookie_observer=*/mojo::NullRemote(),
  4983. /*url_loader_network_observer=*/mojo::NullRemote(),
  4984. /*devtools_observer=*/mojo::NullRemote(),
  4985. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  4986. /*third_party_cookies_enabled=*/true);
  4987. delete_run_loop.Run();
  4988. loader_client.RunUntilComplete();
  4989. ASSERT_EQ(loader_client.completion_status().error_code, net::OK);
  4990. ASSERT_EQ(loader_client.early_hints().size(), 1UL);
  4991. const auto& hints = loader_client.early_hints()[0];
  4992. ASSERT_EQ(hints->headers->link_headers.size(), 1UL);
  4993. const auto& link_header = hints->headers->link_headers[0];
  4994. EXPECT_EQ(link_header->href,
  4995. net::QuicSimpleTestServer::GetFileURL(kPreloadPath));
  4996. }
  4997. TEST_F(URLLoaderTest, CookieReportingCategories) {
  4998. net::test_server::EmbeddedTestServer https_server(
  4999. net::test_server::EmbeddedTestServer::TYPE_HTTPS);
  5000. https_server.SetSSLConfig(
  5001. net::test_server::EmbeddedTestServer::CERT_TEST_NAMES);
  5002. https_server.AddDefaultHandlers(
  5003. base::FilePath(FILE_PATH_LITERAL("services/test/data")));
  5004. ASSERT_TRUE(https_server.Start());
  5005. // SameSite-by-default deprecation warning.
  5006. {
  5007. MockCookieObserver cookie_observer;
  5008. TestURLLoaderClient loader_client;
  5009. ResourceRequest request = CreateResourceRequest(
  5010. "GET", https_server.GetURL("a.test", "/set-cookie?a=b;Secure"));
  5011. // Make this a third-party request.
  5012. url::Origin third_party_origin =
  5013. url::Origin::Create(GURL("http://www.example.com"));
  5014. request.site_for_cookies =
  5015. net::SiteForCookies::FromOrigin(third_party_origin);
  5016. request.trusted_params->isolation_info =
  5017. net::IsolationInfo::CreateForInternalRequest(third_party_origin);
  5018. base::RunLoop delete_run_loop;
  5019. mojo::PendingRemote<mojom::URLLoader> loader;
  5020. context().mutable_factory_params().process_id = kProcessId;
  5021. context().mutable_factory_params().is_corb_enabled = false;
  5022. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5023. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5024. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  5025. request, loader_client.CreateRemote(),
  5026. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  5027. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  5028. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  5029. mojo::NullRemote() /* url_loader_network_observer */,
  5030. /*devtools_observer=*/mojo::NullRemote(),
  5031. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5032. /*third_party_cookies_enabled=*/true);
  5033. delete_run_loop.Run();
  5034. loader_client.RunUntilComplete();
  5035. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  5036. cookie_observer.WaitForCookies(1u);
  5037. EXPECT_THAT(cookie_observer.observed_cookies(),
  5038. testing::ElementsAre(MatchesCookieDetails(
  5039. CookieAccessType::kChange,
  5040. CookieOrLine("a=b", mojom::CookieOrLine::Tag::kCookie),
  5041. false /* is_included */)));
  5042. EXPECT_TRUE(cookie_observer.observed_cookies()[0]
  5043. .status.HasExactlyExclusionReasonsForTesting(
  5044. {net::CookieInclusionStatus::
  5045. EXCLUDE_SAMESITE_UNSPECIFIED_TREATED_AS_LAX}));
  5046. EXPECT_TRUE(cookie_observer.observed_cookies()[0].status.HasWarningReason(
  5047. net::CookieInclusionStatus::WarningReason::
  5048. WARN_SAMESITE_UNSPECIFIED_CROSS_SITE_CONTEXT));
  5049. }
  5050. // Blocked.
  5051. {
  5052. MockCookieObserver cookie_observer(CookieAccessType::kChange);
  5053. TestURLLoaderClient loader_client;
  5054. test_network_delegate()->set_cookie_options(
  5055. net::TestNetworkDelegate::NO_SET_COOKIE);
  5056. ResourceRequest request = CreateResourceRequest(
  5057. "GET", https_server.GetURL("a.test", "/set-cookie?a=b;Secure"));
  5058. // Make this a third-party request.
  5059. url::Origin third_party_origin =
  5060. url::Origin::Create(GURL("http://www.example.com"));
  5061. request.site_for_cookies =
  5062. net::SiteForCookies::FromOrigin(third_party_origin);
  5063. request.trusted_params->isolation_info =
  5064. net::IsolationInfo::CreateForInternalRequest(third_party_origin);
  5065. base::RunLoop delete_run_loop;
  5066. mojo::PendingRemote<mojom::URLLoader> loader;
  5067. context().mutable_factory_params().process_id = kProcessId;
  5068. context().mutable_factory_params().is_corb_enabled = false;
  5069. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5070. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5071. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  5072. request, loader_client.CreateRemote(),
  5073. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  5074. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  5075. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  5076. mojo::NullRemote() /* url_loader_network_observer */,
  5077. /*devtools_observer=*/mojo::NullRemote(),
  5078. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5079. /*third_party_cookies_enabled=*/true);
  5080. delete_run_loop.Run();
  5081. loader_client.RunUntilComplete();
  5082. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  5083. cookie_observer.WaitForCookies(1u);
  5084. EXPECT_THAT(
  5085. cookie_observer.observed_cookies(),
  5086. testing::ElementsAre(MatchesCookieDetails(
  5087. CookieAccessType::kChange,
  5088. CookieOrLine("a=b", mojom::CookieOrLine::Tag::kCookie), false)));
  5089. EXPECT_TRUE(
  5090. cookie_observer.observed_cookies()[0]
  5091. .status.HasExactlyExclusionReasonsForTesting(
  5092. {net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES}));
  5093. test_network_delegate()->set_cookie_options(0);
  5094. }
  5095. // Not permitted by cookie rules, but not the sort of thing that's reported
  5096. // to NetworkContextClient. Note: this uses HTTP, not HTTPS, unlike others;
  5097. // and is in 1st-party context.
  5098. {
  5099. MockCookieObserver cookie_observer;
  5100. TestURLLoaderClient loader_client;
  5101. ResourceRequest request = CreateResourceRequest(
  5102. "GET", test_server()->GetURL("a.test", "/set-cookie?a=b;Secure&d=e"));
  5103. base::RunLoop delete_run_loop;
  5104. mojo::PendingRemote<mojom::URLLoader> loader;
  5105. context().mutable_factory_params().process_id = kProcessId;
  5106. context().mutable_factory_params().is_corb_enabled = false;
  5107. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5108. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5109. loader.InitWithNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone,
  5110. request, loader_client.CreateRemote(),
  5111. nullptr /* sync_url_loader_client */, TRAFFIC_ANNOTATION_FOR_TESTS,
  5112. 0 /* request_id */, 0 /* keepalive_request_size */, nullptr,
  5113. nullptr /* trust_token_helper */, cookie_observer.GetRemote(),
  5114. mojo::NullRemote() /* url_loader_network_observer */,
  5115. /*devtools_observer=*/mojo::NullRemote(),
  5116. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5117. /*third_party_cookies_enabled=*/true);
  5118. delete_run_loop.Run();
  5119. loader_client.RunUntilComplete();
  5120. EXPECT_EQ(net::OK, loader_client.completion_status().error_code);
  5121. cookie_observer.WaitForCookies(1u);
  5122. EXPECT_THAT(
  5123. cookie_observer.observed_cookies(),
  5124. testing::ElementsAre(MatchesCookieDetails(
  5125. CookieAccessType::kChange,
  5126. CookieOrLine("d=e", mojom::CookieOrLine::Tag::kCookie), true)));
  5127. }
  5128. }
  5129. namespace {
  5130. enum class SyncOrAsync { kSync, kAsync };
  5131. class MockTrustTokenRequestHelper : public TrustTokenRequestHelper {
  5132. public:
  5133. // |operation_synchrony| denotes whether to complete the |Begin|
  5134. // and |Finalize| operations synchronously.
  5135. //
  5136. // |begin_done_flag|, if provided, will be set to true immediately before the
  5137. // |Begin| operation returns.
  5138. MockTrustTokenRequestHelper(
  5139. absl::optional<mojom::TrustTokenOperationStatus> on_begin,
  5140. absl::optional<mojom::TrustTokenOperationStatus> on_finalize,
  5141. SyncOrAsync operation_synchrony,
  5142. bool* begin_done_flag = nullptr)
  5143. : on_begin_(on_begin),
  5144. on_finalize_(on_finalize),
  5145. operation_synchrony_(operation_synchrony),
  5146. begin_done_flag_(begin_done_flag) {}
  5147. ~MockTrustTokenRequestHelper() override {
  5148. DCHECK(!on_begin_.has_value())
  5149. << "Begin operation was expected but not performed.";
  5150. DCHECK(!on_finalize_.has_value())
  5151. << "Finalize operation was expected but not performed.";
  5152. }
  5153. MockTrustTokenRequestHelper(const MockTrustTokenRequestHelper&) = delete;
  5154. MockTrustTokenRequestHelper& operator=(const MockTrustTokenRequestHelper&) =
  5155. delete;
  5156. // TrustTokenRequestHelper:
  5157. void Begin(net::URLRequest* request,
  5158. base::OnceCallback<void(mojom::TrustTokenOperationStatus)> done)
  5159. override {
  5160. DCHECK(on_begin_.has_value());
  5161. // Clear storage to crash if the method gets called a second time.
  5162. mojom::TrustTokenOperationStatus result = *on_begin_;
  5163. on_begin_.reset();
  5164. switch (operation_synchrony_) {
  5165. case SyncOrAsync::kSync: {
  5166. OnDoneBeginning(base::BindOnce(std::move(done), result));
  5167. return;
  5168. }
  5169. case SyncOrAsync::kAsync: {
  5170. base::ThreadTaskRunnerHandle::Get()->PostTask(
  5171. FROM_HERE,
  5172. base::BindOnce(&MockTrustTokenRequestHelper::OnDoneBeginning,
  5173. base::Unretained(this),
  5174. base::BindOnce(std::move(done), result)));
  5175. return;
  5176. }
  5177. }
  5178. }
  5179. void Finalize(mojom::URLResponseHead* response,
  5180. base::OnceCallback<void(mojom::TrustTokenOperationStatus)> done)
  5181. override {
  5182. DCHECK(on_finalize_.has_value());
  5183. // Clear storage to crash if the method gets called a second time.
  5184. mojom::TrustTokenOperationStatus result = *on_finalize_;
  5185. on_finalize_.reset();
  5186. switch (operation_synchrony_) {
  5187. case SyncOrAsync::kSync: {
  5188. std::move(done).Run(result);
  5189. return;
  5190. }
  5191. case SyncOrAsync::kAsync: {
  5192. base::ThreadTaskRunnerHandle::Get()->PostTask(
  5193. FROM_HERE, base::BindOnce(std::move(done), result));
  5194. return;
  5195. }
  5196. }
  5197. }
  5198. mojom::TrustTokenOperationResultPtr CollectOperationResultWithStatus(
  5199. mojom::TrustTokenOperationStatus status) override {
  5200. mojom::TrustTokenOperationResultPtr operation_result =
  5201. mojom::TrustTokenOperationResult::New();
  5202. operation_result->status = status;
  5203. return operation_result;
  5204. }
  5205. private:
  5206. void OnDoneBeginning(base::OnceClosure done) {
  5207. if (begin_done_flag_) {
  5208. EXPECT_FALSE(*begin_done_flag_);
  5209. *begin_done_flag_ = true;
  5210. }
  5211. std::move(done).Run();
  5212. }
  5213. // Store mocked function results in Optionals to hit a CHECK failure if a mock
  5214. // method is called without having had a return value specified.
  5215. absl::optional<mojom::TrustTokenOperationStatus> on_begin_;
  5216. absl::optional<mojom::TrustTokenOperationStatus> on_finalize_;
  5217. SyncOrAsync operation_synchrony_;
  5218. raw_ptr<bool> begin_done_flag_;
  5219. };
  5220. class NoopTrustTokenKeyCommitmentGetter : public TrustTokenKeyCommitmentGetter {
  5221. public:
  5222. NoopTrustTokenKeyCommitmentGetter() = default;
  5223. void Get(const url::Origin& origin,
  5224. base::OnceCallback<void(mojom::TrustTokenKeyCommitmentResultPtr)>
  5225. on_done) const override {}
  5226. };
  5227. base::NoDestructor<NoopTrustTokenKeyCommitmentGetter>
  5228. noop_key_commitment_getter{};
  5229. mojom::NetworkContextClient* ReturnNullNetworkContextClient() {
  5230. return nullptr;
  5231. }
  5232. class MockTrustTokenRequestHelperFactory
  5233. : public TrustTokenRequestHelperFactory {
  5234. public:
  5235. MockTrustTokenRequestHelperFactory(
  5236. mojom::TrustTokenOperationStatus creation_failure_error,
  5237. SyncOrAsync sync_or_async)
  5238. : TrustTokenRequestHelperFactory(
  5239. nullptr,
  5240. noop_key_commitment_getter.get(),
  5241. base::BindRepeating(&ReturnNullNetworkContextClient),
  5242. {}),
  5243. sync_or_async_(sync_or_async),
  5244. creation_failure_error_(creation_failure_error) {}
  5245. MockTrustTokenRequestHelperFactory(
  5246. absl::optional<mojom::TrustTokenOperationStatus> on_begin,
  5247. absl::optional<mojom::TrustTokenOperationStatus> on_finalize,
  5248. SyncOrAsync sync_or_async,
  5249. bool* begin_done_flag)
  5250. : TrustTokenRequestHelperFactory(
  5251. nullptr,
  5252. noop_key_commitment_getter.get(),
  5253. base::BindRepeating(&ReturnNullNetworkContextClient),
  5254. {}),
  5255. sync_or_async_(sync_or_async),
  5256. helper_(
  5257. std::make_unique<MockTrustTokenRequestHelper>(on_begin,
  5258. on_finalize,
  5259. sync_or_async,
  5260. begin_done_flag)) {}
  5261. void CreateTrustTokenHelperForRequest(
  5262. const net::URLRequest& request,
  5263. const mojom::TrustTokenParams& params,
  5264. base::OnceCallback<void(TrustTokenStatusOrRequestHelper)> done) override {
  5265. if (creation_failure_error_) {
  5266. switch (sync_or_async_) {
  5267. case SyncOrAsync::kSync: {
  5268. std::move(done).Run(std::move(*creation_failure_error_));
  5269. return;
  5270. }
  5271. case SyncOrAsync::kAsync:
  5272. base::ThreadTaskRunnerHandle::Get()->PostTask(
  5273. FROM_HERE, base::BindOnce(std::move(done),
  5274. std::move(*creation_failure_error_)));
  5275. return;
  5276. }
  5277. }
  5278. switch (sync_or_async_) {
  5279. case SyncOrAsync::kSync: {
  5280. std::move(done).Run(std::move(helper_));
  5281. return;
  5282. }
  5283. case SyncOrAsync::kAsync:
  5284. base::ThreadTaskRunnerHandle::Get()->PostTask(
  5285. FROM_HERE, base::BindOnce(std::move(done), std::move(helper_)));
  5286. return;
  5287. }
  5288. NOTREACHED();
  5289. }
  5290. private:
  5291. SyncOrAsync sync_or_async_;
  5292. absl::optional<mojom::TrustTokenOperationStatus> creation_failure_error_;
  5293. std::unique_ptr<TrustTokenRequestHelper> helper_;
  5294. };
  5295. class MockTrustTokenDevToolsObserver : public MockDevToolsObserver {
  5296. public:
  5297. MockTrustTokenDevToolsObserver() = default;
  5298. ~MockTrustTokenDevToolsObserver() override = default;
  5299. void OnTrustTokenOperationDone(
  5300. const std::string& devtool_request_id,
  5301. network::mojom::TrustTokenOperationResultPtr result) override {
  5302. // Event should be only triggered once.
  5303. EXPECT_FALSE(trust_token_operation_status_.has_value());
  5304. trust_token_operation_status_ = result->status;
  5305. }
  5306. const absl::optional<mojom::TrustTokenOperationStatus>
  5307. trust_token_operation_status() const {
  5308. return trust_token_operation_status_;
  5309. }
  5310. private:
  5311. absl::optional<mojom::TrustTokenOperationStatus>
  5312. trust_token_operation_status_ = absl::nullopt;
  5313. };
  5314. } // namespace
  5315. class URLLoaderSyncOrAsyncTrustTokenOperationTest
  5316. : public URLLoaderTest,
  5317. public ::testing::WithParamInterface<SyncOrAsync> {
  5318. public:
  5319. void OnServerReceivedRequest(const net::test_server::HttpRequest&) override {
  5320. EXPECT_TRUE(outbound_trust_token_operation_was_successful_);
  5321. }
  5322. protected:
  5323. ResourceRequest CreateTrustTokenResourceRequest() {
  5324. ResourceRequest request = CreateResourceRequest(
  5325. "GET", test_server()->GetURL("/simple_page.html"));
  5326. request.trust_token_params =
  5327. OptionalTrustTokenParams(mojom::TrustTokenParams::New());
  5328. // Set the devtools id to trigger the OnTrustTokenOperationDone call.
  5329. request.devtools_request_id = "TEST";
  5330. return request;
  5331. }
  5332. // Maintain a flag, set by the mock trust token request helper, denoting
  5333. // whether we've successfully executed the outbound Trust Tokens operation.
  5334. // This is used to make URLLoader does not send its main request before it
  5335. // has completed the outbound part of its Trust Tokens operation (this
  5336. // involves checking preconditions and potentially annotating the request with
  5337. // Trust Tokens-related request headers).
  5338. bool outbound_trust_token_operation_was_successful_ = false;
  5339. };
  5340. INSTANTIATE_TEST_SUITE_P(WithSyncAndAsyncOperations,
  5341. URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5342. ::testing::Values(SyncOrAsync::kSync,
  5343. SyncOrAsync::kAsync));
  5344. // An otherwise-successful request with an associated Trust Tokens operation
  5345. // whose Begin and Finalize steps are both successful should succeed overall.
  5346. TEST_P(URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5347. HandlesTrustTokenOperationSuccess) {
  5348. ResourceRequest request = CreateTrustTokenResourceRequest();
  5349. base::RunLoop delete_run_loop;
  5350. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  5351. std::unique_ptr<URLLoader> url_loader;
  5352. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  5353. MockTrustTokenDevToolsObserver devtools_observer;
  5354. url_loader = std::make_unique<URLLoader>(
  5355. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5356. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  5357. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5358. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5359. 0 /* keepalive_request_size */, nullptr,
  5360. std::make_unique<MockTrustTokenRequestHelperFactory>(
  5361. mojom::TrustTokenOperationStatus::kOk /* on_begin */,
  5362. mojom::TrustTokenOperationStatus::kOk /* on_finalize */, GetParam(),
  5363. &outbound_trust_token_operation_was_successful_),
  5364. mojo::NullRemote() /* cookie_observer */,
  5365. mojo::NullRemote() /* url_loader_network_observer */,
  5366. devtools_observer.Bind(),
  5367. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5368. /*third_party_cookies_enabled=*/true);
  5369. client()->RunUntilComplete();
  5370. delete_run_loop.Run();
  5371. EXPECT_EQ(client()->completion_status().error_code, net::OK);
  5372. EXPECT_EQ(client()->completion_status().trust_token_operation_status,
  5373. mojom::TrustTokenOperationStatus::kOk);
  5374. // Verify the DevTools event was fired and it has the right status.
  5375. EXPECT_EQ(devtools_observer.trust_token_operation_status(),
  5376. mojom::TrustTokenOperationStatus::kOk);
  5377. // The page should still have loaded.
  5378. base::FilePath file = GetTestFilePath("simple_page.html");
  5379. std::string expected;
  5380. if (!base::ReadFileToString(file, &expected)) {
  5381. ADD_FAILURE() << "File not found: " << file.value();
  5382. return;
  5383. }
  5384. EXPECT_EQ(ReadBody(), expected);
  5385. EXPECT_FALSE(client()->response_head()->headers->raw_headers().empty());
  5386. }
  5387. // A request with an associated Trust Tokens operation whose Begin step returns
  5388. // kAlreadyExists should return a success result immediately, without completing
  5389. // the load.
  5390. //
  5391. // (This is the case exactly when the request is for token redemption, and the
  5392. // Trust Tokens logic determines that there is already a cached redemption
  5393. // record stored locally, obviating the need to execute a redemption
  5394. // operation.)
  5395. TEST_P(URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5396. HandlesTrustTokenRedemptionRecordCacheHit) {
  5397. ResourceRequest request = CreateTrustTokenResourceRequest();
  5398. base::RunLoop delete_run_loop;
  5399. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  5400. std::unique_ptr<URLLoader> url_loader;
  5401. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  5402. MockTrustTokenDevToolsObserver devtools_observer;
  5403. url_loader = std::make_unique<URLLoader>(
  5404. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5405. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  5406. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5407. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5408. 0 /* keepalive_request_size */, nullptr,
  5409. std::make_unique<MockTrustTokenRequestHelperFactory>(
  5410. mojom::TrustTokenOperationStatus::kAlreadyExists /* on_begin */,
  5411. absl::nullopt /* on_finalize */, GetParam(),
  5412. &outbound_trust_token_operation_was_successful_),
  5413. mojo::NullRemote() /* cookie_observer */,
  5414. mojo::NullRemote() /* url_loader_network_observer */,
  5415. devtools_observer.Bind(),
  5416. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5417. /*third_party_cookies_enabled=*/true);
  5418. client()->RunUntilComplete();
  5419. delete_run_loop.Run();
  5420. EXPECT_EQ(client()->completion_status().error_code,
  5421. net::ERR_TRUST_TOKEN_OPERATION_SUCCESS_WITHOUT_SENDING_REQUEST);
  5422. EXPECT_EQ(client()->completion_status().trust_token_operation_status,
  5423. mojom::TrustTokenOperationStatus::kAlreadyExists);
  5424. // Verify the DevTools event was fired and it has the right status.
  5425. EXPECT_EQ(devtools_observer.trust_token_operation_status(),
  5426. mojom::TrustTokenOperationStatus::kAlreadyExists);
  5427. EXPECT_FALSE(client()->response_head());
  5428. EXPECT_FALSE(client()->response_body().is_valid());
  5429. }
  5430. // When a request's associated Trust Tokens operation's Begin step fails, the
  5431. // request itself should fail immediately.
  5432. TEST_P(URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5433. HandlesTrustTokenBeginFailure) {
  5434. ResourceRequest request = CreateTrustTokenResourceRequest();
  5435. base::RunLoop delete_run_loop;
  5436. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  5437. std::unique_ptr<URLLoader> url_loader;
  5438. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  5439. MockTrustTokenDevToolsObserver devtools_observer;
  5440. url_loader = std::make_unique<URLLoader>(
  5441. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5442. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  5443. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5444. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5445. 0 /* keepalive_request_size */, nullptr,
  5446. std::make_unique<MockTrustTokenRequestHelperFactory>(
  5447. mojom::TrustTokenOperationStatus::kFailedPrecondition /* on_begin */,
  5448. absl::nullopt /* on_finalize */, GetParam(),
  5449. &outbound_trust_token_operation_was_successful_),
  5450. mojo::NullRemote() /* cookie_observer */,
  5451. mojo::NullRemote() /* url_loader_network_observer */,
  5452. devtools_observer.Bind(),
  5453. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5454. /*third_party_cookies_enabled=*/true);
  5455. client()->RunUntilComplete();
  5456. delete_run_loop.Run();
  5457. EXPECT_EQ(client()->completion_status().error_code,
  5458. net::ERR_TRUST_TOKEN_OPERATION_FAILED);
  5459. EXPECT_EQ(client()->completion_status().trust_token_operation_status,
  5460. mojom::TrustTokenOperationStatus::kFailedPrecondition);
  5461. // Verify the DevTools event was fired and it has the right status.
  5462. EXPECT_EQ(devtools_observer.trust_token_operation_status(),
  5463. mojom::TrustTokenOperationStatus::kFailedPrecondition);
  5464. EXPECT_FALSE(client()->response_head());
  5465. EXPECT_FALSE(client()->response_body().is_valid());
  5466. }
  5467. // When a request's associated Trust Tokens operation's Begin step succeeds but
  5468. // its Finalize step fails, the request itself should fail.
  5469. TEST_P(URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5470. HandlesTrustTokenFinalizeFailure) {
  5471. ResourceRequest request = CreateTrustTokenResourceRequest();
  5472. base::RunLoop delete_run_loop;
  5473. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  5474. std::unique_ptr<URLLoader> url_loader;
  5475. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  5476. MockTrustTokenDevToolsObserver devtools_observer;
  5477. url_loader = std::make_unique<URLLoader>(
  5478. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5479. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  5480. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5481. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5482. 0 /* keepalive_request_size */, nullptr,
  5483. std::make_unique<MockTrustTokenRequestHelperFactory>(
  5484. mojom::TrustTokenOperationStatus::kOk /* on_begin */,
  5485. mojom::TrustTokenOperationStatus::kBadResponse /* on_finalize */,
  5486. GetParam(), &outbound_trust_token_operation_was_successful_),
  5487. mojo::NullRemote() /* cookie_observer */,
  5488. mojo::NullRemote() /* url_loader_network_observer */,
  5489. devtools_observer.Bind(),
  5490. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5491. /*third_party_cookies_enabled=*/true);
  5492. client()->RunUntilComplete();
  5493. delete_run_loop.Run();
  5494. base::RunLoop().RunUntilIdle();
  5495. EXPECT_EQ(client()->completion_status().error_code,
  5496. net::ERR_TRUST_TOKEN_OPERATION_FAILED);
  5497. EXPECT_EQ(client()->completion_status().trust_token_operation_status,
  5498. mojom::TrustTokenOperationStatus::kBadResponse);
  5499. // Verify the DevTools event was fired and it has the right status.
  5500. EXPECT_EQ(devtools_observer.trust_token_operation_status(),
  5501. mojom::TrustTokenOperationStatus::kBadResponse);
  5502. }
  5503. // When URLLoader receives a request parameterized to perform a Trust Tokens
  5504. // operation but fails to create a trust token request helper (because a
  5505. // universal Trust Tokens precondition is violated, for instance), the request
  5506. // should fail entirely.
  5507. TEST_P(URLLoaderSyncOrAsyncTrustTokenOperationTest,
  5508. HandlesTrustTokenRequestHelperCreationFailure) {
  5509. ResourceRequest request = CreateTrustTokenResourceRequest();
  5510. base::RunLoop delete_run_loop;
  5511. mojo::PendingRemote<mojom::URLLoader> loader_remote;
  5512. std::unique_ptr<URLLoader> url_loader;
  5513. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  5514. MockTrustTokenDevToolsObserver devtools_observer;
  5515. url_loader = std::make_unique<URLLoader>(
  5516. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5517. loader_remote.InitWithNewPipeAndPassReceiver(), 0, request,
  5518. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5519. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5520. 0 /* keepalive_request_size */, nullptr,
  5521. std::make_unique<MockTrustTokenRequestHelperFactory>(
  5522. mojom::TrustTokenOperationStatus::
  5523. kInternalError /* helper_creation_error */,
  5524. GetParam()),
  5525. mojo::NullRemote() /* cookie_observer */,
  5526. mojo::NullRemote() /* url_loader_network_observer */,
  5527. devtools_observer.Bind(),
  5528. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5529. /*third_party_cookies_enabled=*/true);
  5530. client()->RunUntilComplete();
  5531. delete_run_loop.Run();
  5532. EXPECT_EQ(client()->completion_status().error_code,
  5533. net::ERR_TRUST_TOKEN_OPERATION_FAILED);
  5534. EXPECT_EQ(client()->completion_status().trust_token_operation_status,
  5535. mojom::TrustTokenOperationStatus::kInternalError);
  5536. // Verify the DevTools event was fired and it has the right status.
  5537. EXPECT_EQ(devtools_observer.trust_token_operation_status(),
  5538. mojom::TrustTokenOperationStatus::kInternalError);
  5539. }
  5540. TEST_F(URLLoaderTest, OnRawRequestClientSecurityStateFactory) {
  5541. MockDevToolsObserver devtools_observer;
  5542. ResourceRequest request =
  5543. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5544. request.devtools_request_id = "fake-id";
  5545. auto client_security_state = mojom::ClientSecurityState::New();
  5546. client_security_state->is_web_secure_context = false;
  5547. client_security_state->private_network_request_policy =
  5548. mojom::PrivateNetworkRequestPolicy::kAllow;
  5549. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  5550. context().mutable_factory_params().client_security_state =
  5551. std::move(client_security_state);
  5552. context().mutable_factory_params().process_id = kProcessId;
  5553. context().mutable_factory_params().is_corb_enabled = false;
  5554. base::RunLoop delete_run_loop;
  5555. mojo::PendingRemote<mojom::URLLoader> loader;
  5556. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5557. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5558. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  5559. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5560. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5561. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  5562. mojo::NullRemote() /* cookie_observer */,
  5563. mojo::NullRemote() /* url_loader_network_observer */,
  5564. devtools_observer.Bind(),
  5565. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5566. /*third_party_cookies_enabled=*/true);
  5567. delete_run_loop.Run();
  5568. client()->RunUntilComplete();
  5569. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  5570. devtools_observer.WaitUntilRawRequest(0);
  5571. ASSERT_TRUE(devtools_observer.client_security_state());
  5572. EXPECT_EQ(
  5573. devtools_observer.client_security_state()->private_network_request_policy,
  5574. mojom::PrivateNetworkRequestPolicy::kAllow);
  5575. EXPECT_EQ(devtools_observer.client_security_state()->is_web_secure_context,
  5576. false);
  5577. EXPECT_EQ(devtools_observer.client_security_state()->ip_address_space,
  5578. mojom::IPAddressSpace::kPublic);
  5579. }
  5580. TEST_F(URLLoaderTest, OnRawRequestClientSecurityStateRequest) {
  5581. MockDevToolsObserver devtools_observer;
  5582. ResourceRequest request =
  5583. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5584. request.devtools_request_id = "fake-id";
  5585. auto client_security_state = mojom::ClientSecurityState::New();
  5586. client_security_state->is_web_secure_context = false;
  5587. client_security_state->private_network_request_policy =
  5588. mojom::PrivateNetworkRequestPolicy::kAllow;
  5589. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  5590. request.trusted_params->client_security_state =
  5591. std::move(client_security_state);
  5592. context().mutable_factory_params().process_id = kProcessId;
  5593. context().mutable_factory_params().is_corb_enabled = false;
  5594. base::RunLoop delete_run_loop;
  5595. mojo::PendingRemote<mojom::URLLoader> loader;
  5596. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5597. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5598. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  5599. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5600. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5601. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  5602. mojo::NullRemote() /* cookie_observer */,
  5603. mojo::NullRemote() /* url_loader_network_observer */,
  5604. devtools_observer.Bind(),
  5605. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5606. /*third_party_cookies_enabled=*/true);
  5607. delete_run_loop.Run();
  5608. client()->RunUntilComplete();
  5609. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  5610. devtools_observer.WaitUntilRawRequest(0);
  5611. ASSERT_TRUE(devtools_observer.client_security_state());
  5612. EXPECT_EQ(
  5613. devtools_observer.client_security_state()->private_network_request_policy,
  5614. mojom::PrivateNetworkRequestPolicy::kAllow);
  5615. EXPECT_EQ(devtools_observer.client_security_state()->is_web_secure_context,
  5616. false);
  5617. EXPECT_EQ(devtools_observer.client_security_state()->ip_address_space,
  5618. mojom::IPAddressSpace::kPublic);
  5619. }
  5620. TEST_F(URLLoaderTest, OnRawRequestClientSecurityStateNotPresent) {
  5621. MockDevToolsObserver devtools_observer;
  5622. ResourceRequest request =
  5623. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5624. request.devtools_request_id = "fake-id";
  5625. context().mutable_factory_params().process_id = kProcessId;
  5626. context().mutable_factory_params().is_corb_enabled = false;
  5627. base::RunLoop delete_run_loop;
  5628. mojo::PendingRemote<mojom::URLLoader> loader;
  5629. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5630. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5631. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  5632. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5633. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5634. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  5635. mojo::NullRemote() /* cookie_observer */,
  5636. mojo::NullRemote() /* url_loader_network_observer */,
  5637. devtools_observer.Bind(),
  5638. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5639. /*third_party_cookies_enabled=*/true);
  5640. delete_run_loop.Run();
  5641. client()->RunUntilComplete();
  5642. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  5643. devtools_observer.WaitUntilRawRequest(0);
  5644. ASSERT_FALSE(devtools_observer.client_security_state());
  5645. }
  5646. TEST_F(URLLoaderTest, OnRawResponseIPAddressSpace) {
  5647. MockDevToolsObserver devtools_observer;
  5648. ResourceRequest request =
  5649. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5650. request.devtools_request_id = "fake-id";
  5651. context().mutable_factory_params().process_id = kProcessId;
  5652. context().mutable_factory_params().is_corb_enabled = false;
  5653. base::RunLoop delete_run_loop;
  5654. mojo::PendingRemote<mojom::URLLoader> loader;
  5655. std::unique_ptr<URLLoader> url_loader = std::make_unique<URLLoader>(
  5656. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  5657. loader.InitWithNewPipeAndPassReceiver(), 0, request,
  5658. client()->CreateRemote(), nullptr /* sync_url_loader_client */,
  5659. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  5660. 0 /* keepalive_request_size */, nullptr, nullptr /* trust_token_helper */,
  5661. mojo::NullRemote() /* cookie_observer */,
  5662. mojo::NullRemote() /* url_loader_network_observer */,
  5663. devtools_observer.Bind(),
  5664. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  5665. /*third_party_cookies_enabled=*/true);
  5666. delete_run_loop.Run();
  5667. client()->RunUntilComplete();
  5668. EXPECT_EQ(net::OK, client()->completion_status().error_code);
  5669. devtools_observer.WaitUntilRawResponse(0);
  5670. ASSERT_EQ(devtools_observer.resource_address_space(),
  5671. mojom::IPAddressSpace::kLocal);
  5672. }
  5673. TEST_F(URLLoaderMockSocketTest,
  5674. CorbDoesNotCloseSocketsWhenResourcesNotBlocked) {
  5675. corb_enabled_ = true;
  5676. const net::MockWrite kWrites[] = {
  5677. net::MockWrite(net::SYNCHRONOUS, 0,
  5678. "GET / HTTP/1.1\r\n"
  5679. "Host: origin.test\r\n"
  5680. "Connection: keep-alive\r\n"
  5681. "User-Agent: \r\n"
  5682. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5683. };
  5684. net::MockRead kReads[] = {
  5685. net::MockRead(net::SYNCHRONOUS, 1,
  5686. "HTTP/1.1 200 OK\r\n"
  5687. "Connection: keep-alive\r\n"
  5688. "Content-Length: 5\r\n\r\n"),
  5689. net::MockRead(net::SYNCHRONOUS, 2, "Hello"),
  5690. };
  5691. net::SequencedSocketData socket_data(kReads, kWrites);
  5692. socket_factory_.AddSocketDataProvider(&socket_data);
  5693. GURL url("http://origin.test/");
  5694. url::Origin initiator =
  5695. url::Origin::Create(GURL("http://other-origin.test/"));
  5696. ResourceRequest request = CreateResourceRequest("GET", url);
  5697. request.mode = mojom::RequestMode::kCors;
  5698. request.request_initiator = initiator;
  5699. std::string body;
  5700. EXPECT_EQ(net::OK, LoadRequest(request, &body));
  5701. EXPECT_EQ(body, "Hello");
  5702. // Socket should still be alive, in the socket pool.
  5703. EXPECT_TRUE(socket_data.socket());
  5704. }
  5705. TEST_F(URLLoaderMockSocketTest, CorbClosesSocketOnReceivingHeaders) {
  5706. corb_enabled_ = true;
  5707. const net::MockWrite kWrites[] = {
  5708. net::MockWrite(net::SYNCHRONOUS, 0,
  5709. "GET / HTTP/1.1\r\n"
  5710. "Host: origin.test\r\n"
  5711. "Connection: keep-alive\r\n"
  5712. "User-Agent: \r\n"
  5713. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5714. };
  5715. net::MockRead kReads[] = {
  5716. net::MockRead(net::SYNCHRONOUS, 1,
  5717. "HTTP/1.1 200 OK\r\n"
  5718. "Connection: keep-alive\r\n"
  5719. "Content-Type: text/html\r\n"
  5720. "X-Content-Type-Options: nosniff\r\n"
  5721. "Content-Length: 23\r\n\r\n"),
  5722. net::MockRead(net::SYNCHRONOUS, 2, "This should not be read"),
  5723. };
  5724. net::SequencedSocketData socket_data(kReads, kWrites);
  5725. socket_factory_.AddSocketDataProvider(&socket_data);
  5726. GURL url("http://origin.test/");
  5727. url::Origin initiator =
  5728. url::Origin::Create(GURL("http://other-origin.test/"));
  5729. ResourceRequest request = CreateResourceRequest("GET", url);
  5730. request.mode = mojom::RequestMode::kNoCors;
  5731. request.request_initiator = initiator;
  5732. std::string body;
  5733. EXPECT_EQ(net::OK, LoadRequest(request, &body));
  5734. EXPECT_TRUE(body.empty());
  5735. // Socket should have been destroyed, so it will not be reused.
  5736. EXPECT_FALSE(socket_data.socket());
  5737. }
  5738. TEST_F(URLLoaderMockSocketTest,
  5739. CorbDoesNotCloseSocketsWhenResourcesNotBlockedAfterSniffingMimeType) {
  5740. corb_enabled_ = true;
  5741. const net::MockWrite kWrites[] = {
  5742. net::MockWrite(net::SYNCHRONOUS, 0,
  5743. "GET / HTTP/1.1\r\n"
  5744. "Host: origin.test\r\n"
  5745. "Connection: keep-alive\r\n"
  5746. "User-Agent: \r\n"
  5747. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5748. };
  5749. net::MockRead kReads[] = {
  5750. net::MockRead(net::SYNCHRONOUS, 1,
  5751. "HTTP/1.1 200 OK\r\n"
  5752. "Connection: keep-alive\r\n"
  5753. "Content-Type: application/json\r\n"
  5754. "Content-Length: 17\r\n\r\n"),
  5755. net::MockRead(net::SYNCHRONOUS, 2, "Not actually JSON"),
  5756. };
  5757. net::SequencedSocketData socket_data(kReads, kWrites);
  5758. socket_factory_.AddSocketDataProvider(&socket_data);
  5759. GURL url("http://origin.test/");
  5760. url::Origin initiator =
  5761. url::Origin::Create(GURL("http://other-origin.test/"));
  5762. ResourceRequest request = CreateResourceRequest("GET", url);
  5763. request.mode = mojom::RequestMode::kCors;
  5764. request.request_initiator = initiator;
  5765. std::string body;
  5766. EXPECT_EQ(net::OK, LoadRequest(request, &body));
  5767. EXPECT_EQ("Not actually JSON", body);
  5768. // Socket should still be alive, in the socket pool.
  5769. EXPECT_TRUE(socket_data.socket());
  5770. }
  5771. TEST_F(URLLoaderMockSocketTest, CorbClosesSocketOnSniffingMimeType) {
  5772. corb_enabled_ = true;
  5773. const net::MockWrite kWrites[] = {
  5774. net::MockWrite(net::SYNCHRONOUS, 0,
  5775. "GET / HTTP/1.1\r\n"
  5776. "Host: origin.test\r\n"
  5777. "Connection: keep-alive\r\n"
  5778. "User-Agent: \r\n"
  5779. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5780. };
  5781. net::MockRead kReads[] = {
  5782. net::MockRead(net::SYNCHRONOUS, 1,
  5783. "HTTP/1.1 200 OK\r\n"
  5784. "Connection: keep-alive\r\n"
  5785. "Content-Type: application/json\r\n"
  5786. "Content-Length: 9\r\n\r\n"),
  5787. net::MockRead(net::SYNCHRONOUS, 2, "{\"x\" : 3}"),
  5788. };
  5789. net::SequencedSocketData socket_data(kReads, kWrites);
  5790. socket_factory_.AddSocketDataProvider(&socket_data);
  5791. GURL url("http://origin.test/");
  5792. url::Origin initiator =
  5793. url::Origin::Create(GURL("http://other-origin.test/"));
  5794. ResourceRequest request = CreateResourceRequest("GET", url);
  5795. request.mode = mojom::RequestMode::kNoCors;
  5796. request.request_initiator = initiator;
  5797. std::string body;
  5798. EXPECT_EQ(net::OK, LoadRequest(request, &body));
  5799. EXPECT_TRUE(body.empty());
  5800. // Socket should have been destroyed, so it will not be reused.
  5801. EXPECT_FALSE(socket_data.socket());
  5802. }
  5803. TEST_F(URLLoaderMockSocketTest, CorpClosesSocket) {
  5804. auto client_security_state = NewSecurityState();
  5805. client_security_state->cross_origin_embedder_policy.value =
  5806. mojom::CrossOriginEmbedderPolicyValue::kRequireCorp;
  5807. client_security_state->private_network_request_policy =
  5808. mojom::PrivateNetworkRequestPolicy::kAllow;
  5809. set_factory_client_security_state(std::move(client_security_state));
  5810. const net::MockWrite kWrites[] = {
  5811. net::MockWrite(net::SYNCHRONOUS, 0,
  5812. "GET / HTTP/1.1\r\n"
  5813. "Host: origin.test\r\n"
  5814. "Connection: keep-alive\r\n"
  5815. "User-Agent: \r\n"
  5816. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5817. };
  5818. net::MockRead kReads[] = {
  5819. net::MockRead(net::SYNCHRONOUS, 1,
  5820. "HTTP/1.1 200 OK\r\n"
  5821. "Connection: keep-alive\r\n"
  5822. "Content-Type: test/plain\r\n"
  5823. "Content-Length: 23\r\n\r\n"),
  5824. net::MockRead(net::SYNCHRONOUS, 2, "This should not be read"),
  5825. };
  5826. net::SequencedSocketData socket_data(kReads, kWrites);
  5827. socket_factory_.AddSocketDataProvider(&socket_data);
  5828. GURL url("http://origin.test/");
  5829. url::Origin initiator =
  5830. url::Origin::Create(GURL("http://other-origin.test/"));
  5831. ResourceRequest request = CreateResourceRequest("GET", url);
  5832. request.mode = mojom::RequestMode::kNoCors;
  5833. request.request_initiator = initiator;
  5834. EXPECT_EQ(net::ERR_BLOCKED_BY_RESPONSE, LoadRequest(request));
  5835. // Socket should have been destroyed, so it will not be reused.
  5836. EXPECT_FALSE(socket_data.socket());
  5837. }
  5838. TEST_F(URLLoaderMockSocketTest,
  5839. FetchAuctionOnlySignalsFromRendererClosesSocket) {
  5840. auto client_security_state = NewSecurityState();
  5841. client_security_state->private_network_request_policy =
  5842. mojom::PrivateNetworkRequestPolicy::kAllow;
  5843. set_factory_client_security_state(std::move(client_security_state));
  5844. const net::MockWrite kWrites[] = {
  5845. net::MockWrite(net::SYNCHRONOUS, 0,
  5846. "GET / HTTP/1.1\r\n"
  5847. "Host: origin.test\r\n"
  5848. "Connection: keep-alive\r\n"
  5849. "User-Agent: \r\n"
  5850. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5851. };
  5852. net::MockRead kReads[] = {
  5853. net::MockRead(net::SYNCHRONOUS, 1,
  5854. "HTTP/1.1 200 OK\r\n"
  5855. "Connection: keep-alive\r\n"
  5856. "X-FLEDGE-Auction-Only: true\r\n"
  5857. "Content-Type: text/plain\r\n"
  5858. "Content-Length: 23\r\n\r\n"),
  5859. net::MockRead(net::SYNCHRONOUS, 2, "This should not be read"),
  5860. };
  5861. net::SequencedSocketData socket_data(kReads, kWrites);
  5862. socket_factory_.AddSocketDataProvider(&socket_data);
  5863. GURL url("http://origin.test/");
  5864. url::Origin initiator = url::Origin::Create(url);
  5865. ResourceRequest request = CreateResourceRequest("GET", url);
  5866. request.mode = mojom::RequestMode::kNoCors;
  5867. request.request_initiator = initiator;
  5868. EXPECT_EQ(net::ERR_BLOCKED_BY_RESPONSE, LoadRequest(request, /*body=*/nullptr,
  5869. /*is_trusted=*/false));
  5870. // Socket should have been destroyed, so it will not be reused.
  5871. EXPECT_FALSE(socket_data.socket());
  5872. }
  5873. TEST_F(URLLoaderMockSocketTest,
  5874. FetchAuctionOnlySignalsFromBrowserProcessSucceeds) {
  5875. auto client_security_state = NewSecurityState();
  5876. client_security_state->private_network_request_policy =
  5877. mojom::PrivateNetworkRequestPolicy::kAllow;
  5878. set_factory_client_security_state(std::move(client_security_state));
  5879. const net::MockWrite kWrites[] = {
  5880. net::MockWrite(net::SYNCHRONOUS, 0,
  5881. "GET / HTTP/1.1\r\n"
  5882. "Host: origin.test\r\n"
  5883. "Connection: keep-alive\r\n"
  5884. "User-Agent: \r\n"
  5885. "Accept-Encoding: gzip, deflate\r\n\r\n"),
  5886. };
  5887. net::MockRead kReads[] = {
  5888. net::MockRead(net::SYNCHRONOUS, 1,
  5889. "HTTP/1.1 200 OK\r\n"
  5890. "Connection: keep-alive\r\n"
  5891. "X-FLEDGE-Auction-Only: true\r\n"
  5892. "Content-Type: text/plain\r\n"
  5893. "Content-Length: 23\r\n\r\n"),
  5894. net::MockRead(net::SYNCHRONOUS, 2, "This should not be read"),
  5895. };
  5896. net::SequencedSocketData socket_data(kReads, kWrites);
  5897. socket_factory_.AddSocketDataProvider(&socket_data);
  5898. GURL url("http://origin.test/");
  5899. url::Origin initiator = url::Origin::Create(url);
  5900. ResourceRequest request = CreateResourceRequest("GET", url);
  5901. request.mode = mojom::RequestMode::kNoCors;
  5902. request.request_initiator = initiator;
  5903. EXPECT_EQ(net::OK,
  5904. LoadRequest(request, /*body=*/nullptr, /*is_trusted=*/true));
  5905. EXPECT_TRUE(socket_data.socket());
  5906. }
  5907. TEST_F(URLLoaderMockSocketTest, PrivateNetworkRequestPolicyDoesNotCloseSocket) {
  5908. auto client_security_state = NewSecurityState();
  5909. client_security_state->private_network_request_policy =
  5910. mojom::PrivateNetworkRequestPolicy::kBlock;
  5911. set_factory_client_security_state(std::move(client_security_state));
  5912. // No data should be read or written. Trying to do so will assert.
  5913. net::SequencedSocketData socket_data;
  5914. socket_factory_.AddSocketDataProvider(&socket_data);
  5915. GURL url("http://origin.test/");
  5916. url::Origin initiator =
  5917. url::Origin::Create(GURL("http://other-origin.test/"));
  5918. ResourceRequest request = CreateResourceRequest("GET", url);
  5919. request.mode = mojom::RequestMode::kNoCors;
  5920. request.request_initiator = initiator;
  5921. EXPECT_EQ(net::ERR_FAILED, LoadRequest(request));
  5922. // Socket should not be closed, since it can be reused.
  5923. EXPECT_TRUE(socket_data.socket());
  5924. }
  5925. TEST_F(URLLoaderTest, WithDnsAliases) {
  5926. GURL url(test_server_.GetURL(kHostnameWithAliases, "/echo"));
  5927. EXPECT_EQ(net::OK, Load(url));
  5928. ASSERT_TRUE(client_.response_head());
  5929. EXPECT_THAT(client_.response_head()->dns_aliases,
  5930. testing::ElementsAre("alias1", "alias2", "host"));
  5931. }
  5932. TEST_F(URLLoaderTest, NoAdditionalDnsAliases) {
  5933. GURL url(test_server_.GetURL(kHostnameWithoutAliases, "/echo"));
  5934. EXPECT_EQ(net::OK, Load(url));
  5935. ASSERT_TRUE(client_.response_head());
  5936. EXPECT_THAT(client_.response_head()->dns_aliases,
  5937. testing::ElementsAre(kHostnameWithoutAliases));
  5938. }
  5939. TEST_F(URLLoaderTest,
  5940. PrivateNetworkRequestPolicyReportsOnPrivateNetworkRequestWarn) {
  5941. url::Origin initiator =
  5942. url::Origin::Create(GURL("http://other-origin.test/"));
  5943. ResourceRequest request =
  5944. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5945. request.mode = mojom::RequestMode::kNoCors;
  5946. request.request_initiator = initiator;
  5947. request.devtools_request_id = "fake-id";
  5948. auto client_security_state = NewSecurityState();
  5949. client_security_state->is_web_secure_context = false;
  5950. client_security_state->private_network_request_policy =
  5951. mojom::PrivateNetworkRequestPolicy::kWarn;
  5952. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  5953. set_factory_client_security_state(std::move(client_security_state));
  5954. MockDevToolsObserver devtools_observer;
  5955. set_devtools_observer_for_next_request(&devtools_observer);
  5956. EXPECT_EQ(net::OK, LoadRequest(request));
  5957. devtools_observer.WaitUntilPrivateNetworkRequest();
  5958. ASSERT_TRUE(devtools_observer.private_network_request_params());
  5959. auto& params = *devtools_observer.private_network_request_params();
  5960. ASSERT_TRUE(params.client_security_state);
  5961. auto& state = params.client_security_state;
  5962. EXPECT_EQ(state->private_network_request_policy,
  5963. mojom::PrivateNetworkRequestPolicy::kWarn);
  5964. EXPECT_EQ(state->is_web_secure_context, false);
  5965. EXPECT_EQ(state->ip_address_space, mojom::IPAddressSpace::kPublic);
  5966. EXPECT_EQ(params.resource_address_space, mojom::IPAddressSpace::kLocal);
  5967. EXPECT_EQ(params.devtools_request_id, "fake-id");
  5968. EXPECT_TRUE(params.is_warning);
  5969. EXPECT_THAT(params.url.spec(), testing::HasSubstr("simple_page.html"));
  5970. }
  5971. TEST_F(URLLoaderTest,
  5972. PrivateNetworkRequestPolicyReportsOnPrivateNetworkRequestBlock) {
  5973. url::Origin initiator =
  5974. url::Origin::Create(GURL("http://other-origin.test/"));
  5975. ResourceRequest request =
  5976. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  5977. request.mode = mojom::RequestMode::kNoCors;
  5978. request.request_initiator = initiator;
  5979. request.devtools_request_id = "fake-id";
  5980. auto client_security_state = NewSecurityState();
  5981. client_security_state->is_web_secure_context = false;
  5982. client_security_state->private_network_request_policy =
  5983. mojom::PrivateNetworkRequestPolicy::kBlock;
  5984. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  5985. set_factory_client_security_state(std::move(client_security_state));
  5986. MockDevToolsObserver devtools_observer;
  5987. set_devtools_observer_for_next_request(&devtools_observer);
  5988. EXPECT_EQ(net::ERR_FAILED, LoadRequest(request));
  5989. devtools_observer.WaitUntilPrivateNetworkRequest();
  5990. ASSERT_TRUE(devtools_observer.private_network_request_params());
  5991. auto& params = *devtools_observer.private_network_request_params();
  5992. ASSERT_TRUE(params.client_security_state);
  5993. auto& state = params.client_security_state;
  5994. EXPECT_EQ(state->private_network_request_policy,
  5995. mojom::PrivateNetworkRequestPolicy::kBlock);
  5996. EXPECT_EQ(state->is_web_secure_context, false);
  5997. EXPECT_EQ(state->ip_address_space, mojom::IPAddressSpace::kPublic);
  5998. EXPECT_EQ(params.resource_address_space, mojom::IPAddressSpace::kLocal);
  5999. EXPECT_EQ(params.devtools_request_id, "fake-id");
  6000. EXPECT_FALSE(params.is_warning);
  6001. EXPECT_THAT(params.url.spec(), testing::HasSubstr("simple_page.html"));
  6002. }
  6003. TEST_F(URLLoaderTest,
  6004. PrivateNetworkRequestPolicyReportsOnPrivateNetworkRequestAllow) {
  6005. url::Origin initiator =
  6006. url::Origin::Create(GURL("http://other-origin.test/"));
  6007. ResourceRequest request =
  6008. CreateResourceRequest("GET", test_server()->GetURL("/simple_page.html"));
  6009. request.mode = mojom::RequestMode::kNoCors;
  6010. request.request_initiator = initiator;
  6011. request.devtools_request_id = "fake-id";
  6012. auto client_security_state = NewSecurityState();
  6013. client_security_state->is_web_secure_context = false;
  6014. client_security_state->private_network_request_policy =
  6015. mojom::PrivateNetworkRequestPolicy::kAllow;
  6016. client_security_state->ip_address_space = mojom::IPAddressSpace::kPublic;
  6017. set_factory_client_security_state(std::move(client_security_state));
  6018. MockDevToolsObserver devtools_observer;
  6019. set_devtools_observer_for_next_request(&devtools_observer);
  6020. EXPECT_EQ(net::OK, LoadRequest(request));
  6021. // Check that OnPrivateNetworkRequest wasn't triggered.
  6022. devtools_observer.WaitUntilRawResponse(0);
  6023. EXPECT_FALSE(devtools_observer.private_network_request_params());
  6024. }
  6025. // An empty ACCEPT_CH frame should skip the client call.
  6026. TEST_F(URLLoaderFakeTransportInfoTest, AcceptCHFrameEmptyString) {
  6027. net::TransportInfo info = net::DefaultTransportInfo();
  6028. info.accept_ch_frame = "";
  6029. const GURL url("http://fake-endpoint");
  6030. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  6031. url, std::make_unique<FakeTransportInfoInterceptor>(info));
  6032. MockAcceptCHFrameObserver accept_ch_frame_observer;
  6033. set_accept_ch_frame_observer_for_next_request(&accept_ch_frame_observer);
  6034. // Despite its name, IsError(OK) asserts that the matched value is OK.
  6035. EXPECT_THAT(Load(url), IsError(net::OK));
  6036. EXPECT_FALSE(accept_ch_frame_observer.called());
  6037. }
  6038. TEST_F(URLLoaderFakeTransportInfoTest, AcceptCHFrameParseString) {
  6039. net::TransportInfo info = net::DefaultTransportInfo();
  6040. info.accept_ch_frame = "Sec-CH-UA-Platform";
  6041. const GURL url("http://fake-endpoint");
  6042. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  6043. url, std::make_unique<FakeTransportInfoInterceptor>(info));
  6044. MockAcceptCHFrameObserver accept_ch_frame_observer;
  6045. set_accept_ch_frame_observer_for_next_request(&accept_ch_frame_observer);
  6046. // Despite its name, IsError(OK) asserts that the matched value is OK.
  6047. EXPECT_THAT(Load(url), IsError(net::OK));
  6048. EXPECT_THAT(
  6049. accept_ch_frame_observer.accept_ch_frame(),
  6050. testing::ElementsAreArray({mojom::WebClientHintsType::kUAPlatform}));
  6051. }
  6052. TEST_F(URLLoaderFakeTransportInfoTest, AcceptCHFrameRemoveDuplicates) {
  6053. net::TransportInfo info = net::DefaultTransportInfo();
  6054. info.accept_ch_frame = "Sec-CH-UA-Platform, Sec-CH-UA-Model";
  6055. net::HttpRequestHeaders headers;
  6056. headers.SetHeader("Sec-CH-UA-Model", "foo");
  6057. set_additional_headers(headers);
  6058. const GURL url("http://fake-endpoint");
  6059. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  6060. url, std::make_unique<FakeTransportInfoInterceptor>(info));
  6061. MockAcceptCHFrameObserver accept_ch_frame_observer;
  6062. set_accept_ch_frame_observer_for_next_request(&accept_ch_frame_observer);
  6063. EXPECT_THAT(Load(url), IsError(net::OK));
  6064. // Headers should be de-dupped.
  6065. EXPECT_THAT(
  6066. accept_ch_frame_observer.accept_ch_frame(),
  6067. testing::ElementsAreArray({mojom::WebClientHintsType::kUAPlatform}));
  6068. }
  6069. TEST_F(URLLoaderFakeTransportInfoTest, AcceptCHFrameIgnoreMalformed) {
  6070. net::TransportInfo info = net::DefaultTransportInfo();
  6071. // Non-existent hint.
  6072. info.accept_ch_frame = "Foo";
  6073. const GURL url("http://fake-endpoint");
  6074. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  6075. url, std::make_unique<FakeTransportInfoInterceptor>(info));
  6076. MockAcceptCHFrameObserver accept_ch_frame_observer;
  6077. set_accept_ch_frame_observer_for_next_request(&accept_ch_frame_observer);
  6078. // Despite its name, IsError(OK) asserts that the matched value is OK.
  6079. EXPECT_THAT(Load(url), IsError(net::OK));
  6080. EXPECT_FALSE(accept_ch_frame_observer.called());
  6081. }
  6082. #if BUILDFLAG(IS_ANDROID)
  6083. namespace {
  6084. void CheckRadioWakeupTriggerHistograms(base::HistogramTester& histograms,
  6085. size_t expected_count) {
  6086. histograms.ExpectTotalCount(
  6087. kUmaNamePossibleWakeupTriggerURLLoaderRequestDestination, expected_count);
  6088. histograms.ExpectTotalCount(
  6089. kUmaNamePossibleWakeupTriggerURLLoaderRequestPriority, expected_count);
  6090. histograms.ExpectTotalCount(
  6091. kUmaNamePossibleWakeupTriggerURLLoaderRequestIsPrefetch, expected_count);
  6092. histograms.ExpectTotalCount(
  6093. kUmaNamePossibleWakeupTriggerURLLoaderAnnotationId, expected_count);
  6094. }
  6095. } // namespace
  6096. TEST_F(URLLoaderTest, RecordRadioWakeupTrigger_Record) {
  6097. base::HistogramTester histograms;
  6098. net::android::RadioActivityTracker::GetInstance()
  6099. .OverrideRadioActivityForTesting(
  6100. base::android::RadioDataActivity::kDormant);
  6101. net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
  6102. base::android::RadioConnectionType::kCell);
  6103. LoadAndCompareFile("simple_page.html");
  6104. CheckRadioWakeupTriggerHistograms(histograms, /*expected_count=*/1);
  6105. }
  6106. TEST_F(URLLoaderTest, RecordRadioWakeupTrigger_RadioTypeIsNotCell) {
  6107. base::HistogramTester histograms;
  6108. net::android::RadioActivityTracker::GetInstance()
  6109. .OverrideRadioActivityForTesting(
  6110. base::android::RadioDataActivity::kDormant);
  6111. net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
  6112. base::android::RadioConnectionType::kWifi);
  6113. LoadAndCompareFile("simple_page.html");
  6114. CheckRadioWakeupTriggerHistograms(histograms, /*expected_count=*/0);
  6115. }
  6116. TEST_F(URLLoaderTest, RecordRadioWakeupTrigger_RadioActivityIsNotDormant) {
  6117. base::HistogramTester histograms;
  6118. net::android::RadioActivityTracker::GetInstance()
  6119. .OverrideRadioActivityForTesting(
  6120. base::android::RadioDataActivity::kInOut);
  6121. net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
  6122. base::android::RadioConnectionType::kCell);
  6123. LoadAndCompareFile("simple_page.html");
  6124. CheckRadioWakeupTriggerHistograms(histograms, /*expected_count=*/0);
  6125. }
  6126. TEST_F(URLLoaderTest, RecordRadioWakeupTrigger_IntervalTooShort) {
  6127. base::HistogramTester histograms;
  6128. net::android::RadioActivityTracker::GetInstance()
  6129. .OverrideRadioActivityForTesting(
  6130. base::android::RadioDataActivity::kDormant);
  6131. net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
  6132. base::android::RadioConnectionType::kCell);
  6133. net::android::RadioActivityTracker::GetInstance()
  6134. .OverrideLastCheckTimeForTesting(base::TimeTicks::Now());
  6135. LoadAndCompareFile("simple_page.html");
  6136. CheckRadioWakeupTriggerHistograms(histograms, /*expected_count=*/0);
  6137. }
  6138. #endif // BUILDFLAG(IS_ANDROID)
  6139. TEST_F(URLLoaderTest, HasPartitionedCookie) {
  6140. TestURLLoaderClient loader_client;
  6141. ResourceRequest request = CreateResourceRequest(
  6142. "GET", test_server()->GetURL("/set-cookie?a=b;Partitioned;"));
  6143. EXPECT_EQ(net::OK, LoadRequest(request));
  6144. EXPECT_TRUE(client_.response_head()->has_partitioned_cookie);
  6145. }
  6146. using ExtraHeaders = std::vector<std::pair<std::string, std::string>>;
  6147. class URLLoaderCacheTransparencyTest : public URLLoaderTest {
  6148. public:
  6149. void SetUp() override {
  6150. // Needed to start test_server().
  6151. URLLoaderTest::SetUp();
  6152. pervasive_payload_url_ = test_server()->GetURL(kPervasivePayload);
  6153. const GURL redirect_url = test_server()->GetURL(kRedirect301);
  6154. base::FieldTrialParams params;
  6155. params["pervasive-payloads"] = base::StrCat(
  6156. {"1,", pervasive_payload_url_.spec(),
  6157. ",87F6EE26BD9CFC440B4C805AAE79E0A5671F61C00B5E0AF54B8199EAF64AAAC3,",
  6158. redirect_url.spec(),
  6159. // This is actually the checksum for /cacheable.js, the target of the
  6160. // redirect, which shouldn't be considered a candidate for cache
  6161. // transparency.
  6162. ",A791EB1175734A7D8AFC7B78ABA52C537D656D6C4885BAC4B9EE7D377EA090F0"});
  6163. pervasive_payloads_feature_.InitAndEnableFeatureWithParameters(
  6164. features::kPervasivePayloadsList, params);
  6165. cache_transparency_feature_.InitAndEnableFeature(
  6166. features::kCacheTransparency);
  6167. split_cache_feature_.InitAndEnableFeature(
  6168. net::features::kSplitCacheByNetworkIsolationKey);
  6169. // The URL changes for every test, so we have to force the list to be
  6170. // re-read from the feature parameter.
  6171. URLLoader::ResetPervasivePayloadsListForTesting();
  6172. }
  6173. void TearDown() override {
  6174. URLLoaderTest::TearDown();
  6175. URLLoader::ResetPervasivePayloadsListForTesting();
  6176. }
  6177. void OnServerReceivedRequest(
  6178. const net::test_server::HttpRequest& request) override {
  6179. ++network_request_count_;
  6180. }
  6181. // The main difference from Load() is that this can be called multiple times.
  6182. std::unique_ptr<TestURLLoaderClient> SendRequest(
  6183. base::StringPiece path = kPervasivePayload) {
  6184. auto client = std::make_unique<TestURLLoaderClient>();
  6185. ResourceRequest request =
  6186. CreateResourceRequest(method_.c_str(), test_server()->GetURL(path));
  6187. request.load_flags = load_flags_;
  6188. for (const auto& [key, value] : headers_) {
  6189. request.headers.SetHeader(key, value);
  6190. }
  6191. base::RunLoop delete_run_loop;
  6192. mojo::Remote<mojom::URLLoader> loader;
  6193. std::unique_ptr<URLLoader> url_loader;
  6194. context().mutable_factory_params().process_id = mojom::kBrowserProcessId;
  6195. context().mutable_factory_params().is_corb_enabled = false;
  6196. url_loader = std::make_unique<URLLoader>(
  6197. context(), DeleteLoaderCallback(&delete_run_loop, &url_loader),
  6198. loader.BindNewPipeAndPassReceiver(), mojom::kURLLoadOptionNone, request,
  6199. client->CreateRemote(), nullptr /* sync_url_loader_client */,
  6200. TRAFFIC_ANNOTATION_FOR_TESTS, 0 /* request_id */,
  6201. 0 /* keepalive_request_size */, nullptr,
  6202. nullptr /* trust_token_helper */,
  6203. mojo::NullRemote() /* cookie_observer */,
  6204. mojo::NullRemote() /* url_loader_network_observer */,
  6205. /*devtools_observer=*/mojo::NullRemote(),
  6206. /*accept_ch_frame_observer=*/mojo::NullRemote(),
  6207. third_party_cookies_enabled_);
  6208. if (expect_redirect_) {
  6209. client->RunUntilRedirectReceived();
  6210. loader->FollowRedirect({}, {}, {}, absl::nullopt);
  6211. }
  6212. client->RunUntilComplete();
  6213. delete_run_loop.Run();
  6214. return client;
  6215. }
  6216. void SetOrigin(base::StringPiece url) {
  6217. context().mutable_factory_params().isolation_info =
  6218. net::IsolationInfo::CreateForInternalRequest(
  6219. url::Origin::Create(GURL(url)));
  6220. }
  6221. void SendTwoRequestsWithDifferentOrigins(
  6222. base::StringPiece path = kPervasivePayload) {
  6223. SetOrigin("https://a.com/");
  6224. SendRequest(path);
  6225. SetOrigin("https://b.com/");
  6226. SendRequest(path);
  6227. }
  6228. // Causes an expectation failure if the specified reason was not logged.
  6229. void ExpectNotUsedReason(CacheTransparencyCacheNotUsedReason reason) const {
  6230. // The count is 2 because each test sends two requests.
  6231. histogram_tester_.ExpectUniqueSample(kNotUsedHistogram, reason, 2);
  6232. }
  6233. // Causes an expectation failure if any reason was logged.
  6234. void ExpectNoSamples() const {
  6235. histogram_tester_.ExpectTotalCount(kNotUsedHistogram, 0);
  6236. }
  6237. int network_request_count() { return network_request_count_; }
  6238. void set_third_party_cookies_enabled(bool value) {
  6239. third_party_cookies_enabled_ = value;
  6240. }
  6241. void set_method(std::string method) { method_ = std::move(method); }
  6242. void set_load_flags(int flags) { load_flags_ = flags; }
  6243. void set_headers(ExtraHeaders headers) { headers_ = std::move(headers); }
  6244. void set_expect_redirect(bool value) { expect_redirect_ = value; }
  6245. const base::HistogramTester& histogram_tester() { return histogram_tester_; }
  6246. protected:
  6247. static constexpr char kRedirect301[] = "/redirect301-to-cacheable";
  6248. private:
  6249. static constexpr char kPervasivePayload[] = "/pervasive.js";
  6250. static constexpr char kNotUsedHistogram[] =
  6251. "Network.CacheTransparency.CacheNotUsed";
  6252. base::test::ScopedFeatureList pervasive_payloads_feature_;
  6253. base::test::ScopedFeatureList cache_transparency_feature_;
  6254. base::test::ScopedFeatureList split_cache_feature_;
  6255. GURL pervasive_payload_url_;
  6256. int network_request_count_ = 0;
  6257. bool third_party_cookies_enabled_ = true;
  6258. bool expect_redirect_ = false;
  6259. std::string method_ = "GET";
  6260. int load_flags_ = net::LOAD_NORMAL;
  6261. ExtraHeaders headers_;
  6262. base::HistogramTester histogram_tester_;
  6263. };
  6264. TEST_F(URLLoaderCacheTransparencyTest, SuccessfulPervasivePayload) {
  6265. SendTwoRequestsWithDifferentOrigins();
  6266. EXPECT_EQ(1, network_request_count());
  6267. ExpectNotUsedReason(
  6268. CacheTransparencyCacheNotUsedReason::kTryingSingleKeyedCache);
  6269. }
  6270. TEST_F(URLLoaderCacheTransparencyTest, ThirdPartyCookiesDisabled) {
  6271. set_third_party_cookies_enabled(false);
  6272. SendTwoRequestsWithDifferentOrigins();
  6273. EXPECT_EQ(2, network_request_count());
  6274. ExpectNoSamples();
  6275. }
  6276. TEST_F(URLLoaderCacheTransparencyTest, NotAPervasivePayload) {
  6277. SendTwoRequestsWithDifferentOrigins("/cacheable.js");
  6278. EXPECT_EQ(2, network_request_count());
  6279. ExpectNoSamples();
  6280. }
  6281. TEST_F(URLLoaderCacheTransparencyTest, NotAGETRequest) {
  6282. set_method("POST");
  6283. SendTwoRequestsWithDifferentOrigins();
  6284. EXPECT_EQ(2, network_request_count());
  6285. ExpectNotUsedReason(
  6286. CacheTransparencyCacheNotUsedReason::kIncompatibleRequestType);
  6287. }
  6288. TEST_F(URLLoaderCacheTransparencyTest, IncompatibleLoadFlags) {
  6289. set_load_flags(net::LOAD_SKIP_VARY_CHECK);
  6290. SendTwoRequestsWithDifferentOrigins();
  6291. EXPECT_EQ(2, network_request_count());
  6292. ExpectNotUsedReason(
  6293. CacheTransparencyCacheNotUsedReason::kIncompatibleRequestLoadFlags);
  6294. }
  6295. TEST_F(URLLoaderCacheTransparencyTest, IncompatibleHeaders) {
  6296. ExtraHeaders headers = {{"Range", "bytes=0-5"}};
  6297. set_headers(headers);
  6298. SendTwoRequestsWithDifferentOrigins();
  6299. EXPECT_EQ(2, network_request_count());
  6300. ExpectNotUsedReason(
  6301. CacheTransparencyCacheNotUsedReason::kIncompatibleRequestHeaders);
  6302. }
  6303. // Do an end-to-end test of redirects, since their behaviour spans multiple
  6304. // layers.
  6305. TEST_F(URLLoaderCacheTransparencyTest, Redirect) {
  6306. // This use of this histogram is a layering violation. It is not strictly
  6307. // necessary to the test, but helps ensure it is passing for the right reason.
  6308. // TODO(ricea): Stop checking this histogram if it is removed.
  6309. static constexpr char kMarkedUnusableHistogram[] =
  6310. "Network.CacheTransparency.MarkedUnusable";
  6311. set_expect_redirect(true);
  6312. SetOrigin("https://a.com/");
  6313. auto client1 = SendRequest(kRedirect301);
  6314. EXPECT_EQ(client1->redirect_info().status_code, 301);
  6315. histogram_tester().ExpectTotalCount(kMarkedUnusableHistogram, 0);
  6316. SetOrigin("https://b.com/");
  6317. auto client2 = SendRequest(kRedirect301);
  6318. EXPECT_EQ(client2->redirect_info().status_code, 301);
  6319. histogram_tester().ExpectUniqueSample(
  6320. kMarkedUnusableHistogram,
  6321. 1, // index of the URL in the pervasive payloads list
  6322. 1 // number of samples
  6323. );
  6324. // TODO(ricea): Stop checking this histogram if it is removed.
  6325. histogram_tester().ExpectTotalCount(
  6326. "Network.CacheTransparency.SingleKeyedCacheIsUsed", 0);
  6327. // The count includes the target of the redirects.
  6328. EXPECT_EQ(4, network_request_count());
  6329. ExpectNotUsedReason(
  6330. CacheTransparencyCacheNotUsedReason::kTryingSingleKeyedCache);
  6331. }
  6332. } // namespace network