diff --git a/DEPS b/DEPS
index f1d2408..e10d77e 100644
--- a/DEPS
+++ b/DEPS
@@ -306,15 +306,15 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling Skia
   # and whatever else without interference from each other.
-  'skia_revision': '0908f546bfd9e369787d100811fd27d40f09f317',
+  'skia_revision': '7c6b9495b415e59d866df8d10f930b1d34654887',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling V8
   # and whatever else without interference from each other.
-  'v8_revision': '34503e45094863db86a81e71dd4e9ebe0011d986',
+  'v8_revision': '802e4aead6e7cf7f12b406e2cdb389334f7d3e3d',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ANGLE
   # and whatever else without interference from each other.
-  'angle_revision': '1bdb403899f2040a7b816b3261f13a48914d439c',
+  'angle_revision': '9a70fc9046644c2a3b4bb1ea9f0e56fe19473941',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling SwiftShader
   # and whatever else without interference from each other.
@@ -421,7 +421,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'dawn_revision': 'cdfcfcabd1400a1552ba7d3c6a92dbb28a83fd76',
+  'dawn_revision': 'b268f525fc231d4f545ae9a40f002b46276bdd17',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
@@ -497,7 +497,7 @@
 
   # If you change this, also update the libc++ revision in
   # //buildtools/deps_revisions.gni.
-  'libcxx_revision':       '0ec946fa26f0ad25ad366e5f7acdec2ab8ceed2a',
+  'libcxx_revision':       '9e4e987c282a170f6daf8b3c8b52d101d2346f68',
 
   # GN CIPD package version.
   'gn_version': 'git_revision:92e63272dc04ee7cc1eaae2633c25da06e4f9c03',
@@ -821,7 +821,7 @@
 
   'src/clank': {
     'url': Var('chrome_git') + '/clank/internal/apps.git' + '@' +
-    'bdc4d4d785d044cf585fb255b69f7283eed1f721',
+    'bd44c4cb90445bd38f361c33924f84a375e17f6f',
     'condition': 'checkout_android and checkout_src_internal',
   },
 
@@ -1221,7 +1221,7 @@
     Var('chromium_git') + '/devtools/devtools-frontend' + '@' + Var('devtools_frontend_revision'),
 
   'src/third_party/devtools-frontend-internal': {
-      'url': Var('chrome_git') + '/devtools/devtools-internal.git' + '@' + '5884a35e7f4cccefa590f690f1021d013b8bb06e',
+      'url': Var('chrome_git') + '/devtools/devtools-internal.git' + '@' + '831ddb26c27ea70c10a67d34ddf4bd41276e667f',
     'condition': 'checkout_src_internal',
   },
 
@@ -1831,7 +1831,7 @@
       'dep_type': 'cipd',
   },
 
-  'src/third_party/vulkan-deps': '{chromium_git}/vulkan-deps@2e96f5c2b566dc69b5f30295c85f5e6a19af60e5',
+  'src/third_party/vulkan-deps': '{chromium_git}/vulkan-deps@860dca03b6e71b58e85a6fd261f40e487355008f',
 
   'src/third_party/vulkan_memory_allocator':
     Var('chromium_git') + '/external/github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git' + '@' + '56300b29fbfcc693ee6609ddad3fdd5b7a449a21',
@@ -1871,7 +1871,7 @@
     Var('chromium_git') + '/external/github.com/gpuweb/cts.git' + '@' + '6e75f19212e3deaebd5bd8542fe10a6fdedc0cdf',
 
   'src/third_party/webrtc':
-    Var('webrtc_git') + '/src.git' + '@' + '5116ad58b15b7d56aecc377d06765c3200242b3e',
+    Var('webrtc_git') + '/src.git' + '@' + '2561dd307eaedb9baa8c0cde1fec26d627b777cf',
 
   # Wuffs' canonical repository is at github.com/google/wuffs, but we use
   # Skia's mirror of Wuffs, the same as in upstream Skia's DEPS file.
@@ -1994,7 +1994,7 @@
     'packages': [
       {
         'package': 'chromeos_internal/apps/help_app/app',
-        'version': 'SufN-kJqrnG5Gw46X9isgCkTtra-eoQF1DbloYnNgloC',
+        'version': 'C2OtPysCbdQzrD5sPsG1pmOCxVEF4X0lY_a5DxsHzRIC',
       },
     ],
     'condition': 'checkout_chromeos and checkout_src_internal',
@@ -2005,7 +2005,7 @@
     'packages': [
       {
         'package': 'chromeos_internal/apps/media_app/app',
-        'version': 'iPP8IL6nqAxTXfcYLGP7X3EhX_Oe5VBD1NaoQBgaE2kC',
+        'version': 'uCWInBZeShewO9ae6l-kt9I2thnc1yytoKUmv1J2gJ0C',
       },
     ],
     'condition': 'checkout_chromeos and checkout_src_internal',
@@ -2038,7 +2038,7 @@
     'packages': [
       {
         'package': 'chromeos_internal/apps/projector_app/app',
-        'version': 'yYKCrEgbq_ihHbGGhEs7ZNHlIcVOEOrUP6cZ64T3DasC',
+        'version': 'Tf7tTFqaVGMj9g4gukXW1U76mI_hVII_fp4C9L2g5c8C',
       },
     ],
     'condition': 'checkout_chromeos and checkout_src_internal',
@@ -4028,7 +4028,7 @@
 
   'src/ios_internal':  {
       'url': Var('chrome_git') + '/chrome/ios_internal.git' + '@' +
-        '48a0c3d37606ddb07e381e1239ac760e88096f1a',
+        'c55e94d4564fb697d3d83fe9fcbafaffce2e139e',
       'condition': 'checkout_ios and checkout_src_internal',
   },
 
diff --git a/buildtools/deps_revisions.gni b/buildtools/deps_revisions.gni
index c3b6e476..a031801 100644
--- a/buildtools/deps_revisions.gni
+++ b/buildtools/deps_revisions.gni
@@ -5,5 +5,5 @@
 declare_args() {
   # Used to cause full rebuilds on libc++ rolls. This should be kept in sync
   # with the libcxx_revision vars in //DEPS.
-  libcxx_revision = "0ec946fa26f0ad25ad366e5f7acdec2ab8ceed2a"
+  libcxx_revision = "9e4e987c282a170f6daf8b3c8b52d101d2346f68"
 }
diff --git a/chrome/VERSION b/chrome/VERSION
index e0acd2e7..378a02e9 100644
--- a/chrome/VERSION
+++ b/chrome/VERSION
@@ -1,4 +1,4 @@
 MAJOR=121
 MINOR=0
-BUILD=6149
+BUILD=6151
 PATCH=0
diff --git a/chrome/android/profiles/arm.newest.txt b/chrome/android/profiles/arm.newest.txt
index 994a5d66..157b166 100644
--- a/chrome/android/profiles/arm.newest.txt
+++ b/chrome/android/profiles/arm.newest.txt
@@ -1 +1 @@
-chromeos-chrome-arm-121.0.6146.0_rc-r1-merged.afdo.bz2
+chromeos-chrome-arm-121.0.6148.0_rc-r1-merged.afdo.bz2
diff --git a/chrome/android/profiles/newest.txt b/chrome/android/profiles/newest.txt
index d9489d06..b36cf90c 100644
--- a/chrome/android/profiles/newest.txt
+++ b/chrome/android/profiles/newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-121.0.6146.0_rc-r1-merged.afdo.bz2
+chromeos-chrome-amd64-121.0.6148.0_rc-r1-merged.afdo.bz2
diff --git a/chrome/app/resources/chromium_strings_sk.xtb b/chrome/app/resources/chromium_strings_sk.xtb
index 97b31c2..4056ab8 100644
--- a/chrome/app/resources/chromium_strings_sk.xtb
+++ b/chrome/app/resources/chromium_strings_sk.xtb
@@ -38,7 +38,9 @@
 <translation id="1715127912119967311">Chromium odosiela vaše interakcie s nimi Googlu, aby pomohol tieto funkcie zlepšovať. Tieto údaje môžu čítať, spracúvať a označovať poznámkami kontrolóri.</translation>
 <translation id="17264556997921157">Môžete si prezrieť témy záujmu, pomocou ktorých vám weby zobrazujú reklamy, a odstrániť ich. Chromium odhaduje záujmy na základe nedávnej histórie prehliadania.</translation>
 <translation id="1733725117201708356">Chromium čoskoro odstráni dáta prehliadania</translation>
+<translation id="1736443181683099871">Chromium sa pokúsi inovovať navigácie na HTTPS</translation>
 <translation id="1745121272106313518">Chromium sa reštartuje o <ph name="REMAINING_TIME" /></translation>
+<translation id="1749104137266986751">Keď HTTPS nie je k dispozícii, Chromium bude bez upozornenia používať nezabezpečené pripojenie</translation>
 <translation id="1774152462503052664">Povoliť prehliadaču Chromium spustenie na pozadí</translation>
 <translation id="1779356040007214683">Z dôvodu vyššej bezpečnosti prehliadača Chromium sme zakázali niektoré rozšírenia, ktoré nedodáva <ph name="IDS_EXTENSION_WEB_STORE_TITLE" /> a mohli byť pridané bez vášho vedomia.</translation>
 <translation id="1808667845054772817">Preinštalovať prehliadač Chromium</translation>
@@ -126,6 +128,7 @@
 <translation id="3286538390144397061">Reštartovať</translation>
 <translation id="328888136576916638">Chýbajú kľúče rozhrania Google API. Niektoré funkcie prehliadača Google Chromium budú zakázané.</translation>
 <translation id="3296368748942286671">Po zatvorení prehliadača Chromium ponechať spustené aplikácie na pozadí</translation>
+<translation id="3313189106987092621">Chromium vás bude pred načítaním webu používajúceho nezabezpečené pripojenie upozorňovať</translation>
 <translation id="3350761136195634146">Profil prehliadača Chromium s týmto účtom už existuje</translation>
 <translation id="3387527074123400161">Chromium OS</translation>
 <translation id="3406848076815591792">Chcete prepnúť na existujúci profil prehliadača Chromium?</translation>
@@ -223,6 +226,7 @@
 <translation id="5224391634244552924">Žiadne uložené heslá. Chromium môže skontrolovať heslá, keď ich uložíte.</translation>
 <translation id="5252179775517634216">Používateľ <ph name="EXISTING_USER" /> je už do tohto profilu prehliadača Chromium prihlásený. Týmto sa vytvorí nový profil prehliadača Chromium pre <ph name="USER_EMAIL_ADDRESS" /></translation>
 <translation id="5277894862589591112">Ak chcete zmeny použiť, spustite Chromium znova</translation>
+<translation id="5294316920224716406">Pri prehliadaní v režime inkognito vás bude Chromium pred načítaním webu používajúceho nezabezpečené pripojenie upozorňovať</translation>
 <translation id="5296845517486664001">Keď sú zapnuté skúšobné obdobia a ak vás Chromium náhodne zapojil do aktívneho skúšobného obdobia, vaša história prehliadania ovplyvňuje zobrazované reklamy a záujmy, ktoré sú odhadnuté nižšie. Chromium priebežne odstraňuje vaše záujmy každý mesiac, aby tak chránil vaše súkromie.</translation>
 <translation id="5352264705793813212">Prehliadač Chromium našiel niekoľko bezpečnostných odporúčaní, ktoré by ste si mali pozrieť</translation>
 <translation id="5358375970380395591">Prihlasujete sa pomocou spravovaného účtu a jeho správcovi dávate kontrolu nad vaším profilom Chromium. Vaše údaje prehliadača Chromium, ako sú aplikácie, záložky, história, heslá a iné nastavenia, sa natrvalo priradia k účtu <ph name="USER_NAME" />. Tieto údaje budete môcť odstrániť len pomocou panela Dashboard v Účtoch Google, ale nebudete ich môcť priradiť k inému účtu. <ph name="LEARN_MORE" /></translation>
diff --git a/chrome/app/resources/generated_resources_sk.xtb b/chrome/app/resources/generated_resources_sk.xtb
index f39783f..0fc171e 100644
--- a/chrome/app/resources/generated_resources_sk.xtb
+++ b/chrome/app/resources/generated_resources_sk.xtb
@@ -581,6 +581,7 @@
 <translation id="1461041542809785877">Výkonnosť</translation>
 <translation id="1461177659295855031">Presunúť do priečinka panela so záložkami</translation>
 <translation id="1461288887896722288">Práve ste sa prihlásili do spravovaného účtu. Ak vytvoríte nový spravovaný profil, budete mať prístup k niektorým zdrojom prepojeným s týmto účtom.</translation>
+<translation id="1461868306585780092">Upozorňovať pred použitím nezabezpečených pripojení</translation>
 <translation id="146219525117638703">Stav ONC</translation>
 <translation id="146220085323579959">Internet je odpojený. Skontrolujte svoje pripojenie k Internetu a skúste znova.</translation>
 <translation id="1462480037563370607">Manuálne pridanie webov</translation>
@@ -1560,6 +1561,7 @@
 <translation id="2180620921879609685">Blokovať obsah na akejkoľvek stránke</translation>
 <translation id="2181821976797666341">Pravidlá</translation>
 <translation id="2182058453334755893">Skopírované do schránky</translation>
+<translation id="2182419606502127232">Zahrnúť moje denníky servera</translation>
 <translation id="2183570493397356669">Tlačidlo Pokračovať je deaktivované</translation>
 <translation id="2184515124301515068">Povoľte Chromu vyberať, kedy môžu weby prehrať zvuk (odporúčané)</translation>
 <translation id="2186206192313702726">Google Lens</translation>
@@ -1753,6 +1755,7 @@
 <translation id="2323018538045954000">Uložené siete Wi-Fi</translation>
 <translation id="2325444234681128157">Zapamätať si heslo</translation>
 <translation id="2326188115274135041">Potvrdením kódu PIN zapnite automatické odomykanie</translation>
+<translation id="2326906096734221931">Otvoriť nastavenia aplikácie</translation>
 <translation id="2326931316514688470">&amp;Znova načítať aplikáciu</translation>
 <translation id="2327492829706409234">Povoliť aplikáciu</translation>
 <translation id="2327920026543055248">Zadajte <ph name="CHARACTER" />. znak z <ph name="TOTAL" /></translation>
@@ -3890,6 +3893,7 @@
 <translation id="399788104667917863">Pripnúť na panel s nástrojmi</translation>
 <translation id="3998976413398910035">Spravovať tlačiarne</translation>
 <translation id="4001540981461989979">Zvýrazniť kurzor myši pri pohybe</translation>
+<translation id="4002347779798688515">Stiahnutý profil sa možno nebude dať použiť, keď je poskytovateľ mobilnej siete uzamknutý. Ak potrebujete podporu, kontaktujte svojho poskytovateľa.</translation>
 <translation id="4002440992267487163">Nastavenie kódu PIN</translation>
 <translation id="4005817994523282006">Metóda zisťovania časového pásma</translation>
 <translation id="4007856537951125667">Skryť skratky</translation>
@@ -5426,6 +5430,7 @@
 <translation id="5261683757250193089">Otvoriť v Internetovom obchode</translation>
 <translation id="5261799091118902550">Tento súbor môže byť vírus alebo malvér. Môžete ho odoslať Googlu, ktorý skontroluje, či je bezpečný.</translation>
 <translation id="5262784498883614021">Automaticky pripojiť k sieti</translation>
+<translation id="5263656105659419083">Na bočný panel sa ľahko vrátite kliknutím na Pripnúť vpravo hore</translation>
 <translation id="5264148714798105376">Môže to chvíľu trvať.</translation>
 <translation id="5264252276333215551">Ak chcete aplikáciu spustiť v režime verejného terminálu, pripojte sa k internetu.</translation>
 <translation id="5265797726250773323">Pri inštalácii sa vyskytla chyba</translation>
@@ -5573,6 +5578,7 @@
 <translation id="5388567882092991136">{NUM_SITES,plural, =1{Bol nájdený 1 web s množstvom upozornení}few{Boli nájdené {NUM_SITES} weby s množstvom upozornení}many{Found {NUM_SITES} sites with lots of notifications}other{Bolo nájdených {NUM_SITES} webov s množstvom upozornení}}</translation>
 <translation id="5388885445722491159">Spárované</translation>
 <translation id="5389626883706033615">Weby majú zablokované žiadať vás o používanie informácií, ktoré o vás uložili</translation>
+<translation id="5389794555912875905">Zobrazovať upozornenia pred prejdením na nezabezpečené weby (odporúčané)</translation>
 <translation id="5390112241331447203">Zahŕňať súbor system_logs.txt odosielaný v hláseniach spätnej väzby</translation>
 <translation id="5390677308841849479">Tmavočervená a oranžová</translation>
 <translation id="5390743329570580756">Odoslať pre</translation>
@@ -5856,6 +5862,7 @@
 <translation id="5608580678041221894">Oblasť orezania môžete upraviť alebo presunúť klepnutím na nasledujúce klávesy</translation>
 <translation id="5609231933459083978">Aplikácia je pravdepodobne neplatná.</translation>
 <translation id="561030196642865721">Na tomto webe sú povolené súbory cookie tretích strán</translation>
+<translation id="561236229031062396"><ph name="SHORTCUT_NAME" />, <ph name="APP_FULL_NAME" /></translation>
 <translation id="5612734644261457353">Je nám ľúto, stále sa nedarí overiť vaše heslo. Poznámka: Ak ste nedávno zmenili heslo, vaše nové heslo bude použité až po odhlásení. Použite svoje staré heslo.</translation>
 <translation id="5614190747811328134">Oznámenie pre používateľa</translation>
 <translation id="5614553682702429503">Uložiť heslo?</translation>
@@ -6210,6 +6217,7 @@
 <translation id="5901089233978050985">Prepnúť na zaznamenávanú kartu</translation>
 <translation id="5901494423252125310">Dvierka tlačiarne sú otvorené</translation>
 <translation id="5901630391730855834">Žltá</translation>
+<translation id="5902892210366342391">Zobrazovať upozornenia pred prejdením na nezabezpečené weby v režime inkognito</translation>
 <translation id="5904614460720589786"><ph name="APP_NAME" /> sa nepodarilo nastaviť pre problém s konfiguráciou. Kontaktujte správcu. Kód chyby: <ph name="ERROR_CODE" />.</translation>
 <translation id="5906655207909574370">Aktualizácia je takmer hotová! Dokončite ju reštartovaním zariadenia.</translation>
 <translation id="5906732635754427568">Dáta priradené k danej aplikácii budú odstránené z tohto zariadenia.</translation>
@@ -6747,6 +6755,7 @@
 <translation id="6333170995003625229">Vašu e‑mailovú adresu alebo heslo sa nepodarilo overiť. Skúste sa prihlásiť znova.</translation>
 <translation id="6334267141726449402">Skopírujte a odošlite tento odkaz používateľovi, aby mohol zhromažďovať denníky.</translation>
 <translation id="6336038146639916978">Doména <ph name="MANAGER" /> deaktivovala ladenie ADB. Vaše zariadenie <ph name="DEVICE_TYPE" /> sa o 24 hodín resetuje. Zálohujte všetky súbory, ktoré si chcete ponechať.</translation>
+<translation id="6336194758029258346">Jazyk aplikácie</translation>
 <translation id="6337543438445391085">V údajoch môžu byť stále zahrnuté niektoré osobné údaje. Nezabudnite skontrolovať exportované súbory.</translation>
 <translation id="6338968693068997776">Pridajte zariadenie USB</translation>
 <translation id="6339668969738228384">Vytvoriť nový profil pre používateľa <ph name="USER_EMAIL_ADDRESS" /></translation>
@@ -7256,6 +7265,7 @@
 <translation id="676158322851696513">„<ph name="EXTENSION_NAME" />“</translation>
 <translation id="6761623907967804682">Dáta webov v zariadení nie sú povolené</translation>
 <translation id="6762833852331690540">Zapnuté</translation>
+<translation id="6762861159308991328">V nastaveniach aplikácie môžete zmeniť, ako sa odkazy otvárajú</translation>
 <translation id="676560328519657314">Vaše spôsoby platby v službe Google Pay</translation>
 <translation id="6766488013065406604">Prejsť do Správcu hesiel Google</translation>
 <translation id="6767566652486411142">Vybrať iný jazyk…</translation>
@@ -7471,6 +7481,7 @@
 <translation id="6912007319859991306">Kód PIN mobilnej SIM karty</translation>
 <translation id="6912380255120084882">Vyskúšajte iné zariadenie</translation>
 <translation id="691289340230098384">Predvoľby titulkov</translation>
+<translation id="6914812290245989348">Nezobrazovať upozornenia pred prejdením na nezabezpečené weby</translation>
 <translation id="6916590542764765824">Spravovať rozšírenia</translation>
 <translation id="6918677045355889289">Vyžaduje sa aktualizácia systému Chrome OS</translation>
 <translation id="6919354101107095996">Skúste sa na webe prihlásiť. Potom položku stiahnite znova.</translation>
@@ -8953,6 +8964,7 @@
 <translation id="8076835018653442223">Prístup k miestnym súborom vo vašom zariadení zakázal správca</translation>
 <translation id="8077120325605624147">Všetky weby, ktoré navštívite, vám môžu zobrazovať ľubovoľné reklamy</translation>
 <translation id="8077579734294125741">Ďalšie profily Chromu</translation>
+<translation id="80790299200510644">Vyhľadávanie podľa obrázkov</translation>
 <translation id="80798452873915119">Weby môžu žiadať o povolenie spravovať okná na všetkých obrazovkách</translation>
 <translation id="8080028325999236607">Zavrieť všetky karty</translation>
 <translation id="808089508890593134">Google</translation>
diff --git a/chrome/app/resources/google_chrome_strings_sk.xtb b/chrome/app/resources/google_chrome_strings_sk.xtb
index 405c6e3..64d3f6d7 100644
--- a/chrome/app/resources/google_chrome_strings_sk.xtb
+++ b/chrome/app/resources/google_chrome_strings_sk.xtb
@@ -99,6 +99,7 @@
 <translation id="2556847002339236023">Ak sa Chrome nebude používať <ph name="TIMEOUT_DURATION" />, vaša organizácia ho zavrie. Dáta prehliadania boli odstránené. Môže to zahŕňať históriu, automatické dopĺňanie a stiahnuté súbory.</translation>
 <translation id="2559253115192232574">Neskôr môže web, ktorý navštívite, požiadať Chrome o vaše záujmy, aby vám mohol prispôsobiť zobrazované reklamy. Chrome môže zdieľať až tri záujmy.</translation>
 <translation id="2563121210305478421">Chcete Chrome znova spustiť?</translation>
+<translation id="2569974318947988067">Chrome sa pokúsi inovovať navigácie na HTTPS</translation>
 <translation id="2574930892358684005">Používateľ <ph name="EXISTING_USER" /> je už do tohto profilu Chromu prihlásený. Ak chcete oddeliť svoje prehliadanie, Chrome vám môže vytvoriť vlastný profil.</translation>
 <translation id="2580411288591421699">Nie je možné nainštalovať rovnakú verziu prehliadača Google Chrome, ako je aktuálne spustená verzia. Zavrite Google Chrome a skúste znova.</translation>
 <translation id="2586406160782125153">Táto akcia odstráni zo zariadenia údaje prehliadania. Ak budete chcieť svoje údaje neskôr opäť načítať, prihláste sa do Chromu ako používateľ <ph name="USER_EMAIL" />.</translation>
@@ -215,6 +216,7 @@
 <translation id="4335235004908507846">Chrome vás môže chrániť pred porušeniami ochrany údajov, škodlivými rozšíreniami a ďalšími hrozbami</translation>
 <translation id="4343195214584226067">Rozšírenie <ph name="EXTENSION_NAME" /> bolo pridané do Chromu</translation>
 <translation id="4384570495110188418">Chrome nemôže skontrolovať heslá, pretože ste sa neprihlásili</translation>
+<translation id="4389991535395284064">Pri prehliadaní v režime inkognito vás bude Chrome pred načítaním webu používajúceho nezabezpečené pripojenie upozorňovať</translation>
 <translation id="4393248995085527349">Ak chcete dostávať budúce aktualizácie prehliadača Google Chrome, musíte používať systém macOS 10.15 alebo novší. V tomto počítači používate macOS 10.13.</translation>
 <translation id="4427306783828095590">Rozšírená ochrana efektívnejšie blokuje phishing aj malvér</translation>
 <translation id="4450664632294415862">Chrome – prihlásenie do siete – <ph name="PAGE_TITLE" /></translation>
@@ -387,6 +389,7 @@
 <translation id="7426611252293106642">Google Chrome nemusí fungovať správne, pretože v tejto verzii systému Linux už nie je podporovaný</translation>
 <translation id="7449333426561673451">{COUNT,plural, =1{Vaša organizácia Chrome automaticky zavrie, keď sa nebude používať jednu minútu.}few{Vaša organizácia Chrome automaticky zavrie, keď sa nebude používať # minúty.}many{Vaša organizácia Chrome automaticky zavrie, keď sa nebude používať # minúty.}other{Vaša organizácia Chrome automaticky zavrie, keď sa nebude používať # minút.}}</translation>
 <translation id="7452987490177144319">{COUNT,plural, =1{Vaša organizácia automaticky odstráni dáta prehliadania, keď sa Chrome nebude používať jednu minútu. Môže v nich byť zahrnutá história, automatické dopĺňanie a stiahnuté súbory. Vaše karty zostanú otvorené.}few{Vaša organizácia automaticky odstráni dáta prehliadania, keď sa Chrome nebude používať # minúty. Môže v nich byť zahrnutá história, automatické dopĺňanie a stiahnuté súbory. Vaše karty zostanú otvorené.}many{Vaša organizácia automaticky odstráni dáta prehliadania, keď sa Chrome nebude používať # minúty. Môže v nich byť zahrnutá história, automatické dopĺňanie a stiahnuté súbory. Vaše karty zostanú otvorené.}other{Vaša organizácia automaticky odstráni dáta prehliadania, keď sa Chrome nebude používať # minút. Môže v nich byť zahrnutá história, automatické dopĺňanie a stiahnuté súbory. Vaše karty zostanú otvorené.}}</translation>
+<translation id="7477130805345743099">Chrome vás bude pred načítaním webu používajúceho nezabezpečené pripojenie upozorňovať</translation>
 <translation id="7481213027396403996">Získajte najsilnejšie zabezpečenie Chromu</translation>
 <translation id="7535429826459677826">Google Chrome verzie pre vývojárov</translation>
 <translation id="7583399374488819119">Inštalátor aplikácie <ph name="COMPANY_NAME" /></translation>
@@ -478,6 +481,7 @@
 <translation id="8922193594870374009">Ak chcete zo zariadenia <ph name="ORIGIN" /> odoslať číslo do svojho telefónu s Androidom, prihláste sa v oboch zariadeniach do Chromu.</translation>
 <translation id="8986207147630327271">Do tohto prehliadača pridávate pracovný profil a svojmu správcovi udeľujete kontrolu iba nad ním.</translation>
 <translation id="8989968390305463310">Vaša história prehliadania ovplyvňuje zobrazované reklamy a záujmy, ktoré sú odhadnuté nižšie. Chrome priebežne automaticky odstraňuje vaše záujmy každý mesiac, aby tak chránil vaše súkromie. Záujmy sa môžu obnoviť, pokiaľ ich neodstránite.</translation>
+<translation id="8999117580775242387">Keď HTTPS nie je k dispozícii, Chrome bude bez upozornenia používať nezabezpečené pripojenie</translation>
 <translation id="8999208279178790196">{0,plural, =0{Je k dispozícii aktualizácia Chromu}=1{Je k dispozícii aktualizácia Chromu}few{Aktualizácia Chromu je k dispozícii už # dni}many{Aktualizácia Chromu je k dispozícii už # dňa}other{Aktualizácia Chromu je k dispozícii už # dní}}</translation>
 <translation id="9053892488859122171">Systém Chrome OS Flex</translation>
 <translation id="9054037008353851982">Aktualizujete opätovným spustením (karty sa znova otvoria)</translation>
diff --git a/chrome/browser/optimization_guide/optimization_guide_keyed_service.cc b/chrome/browser/optimization_guide/optimization_guide_keyed_service.cc
index 8988442f..f2366da 100644
--- a/chrome/browser/optimization_guide/optimization_guide_keyed_service.cc
+++ b/chrome/browser/optimization_guide/optimization_guide_keyed_service.cc
@@ -311,7 +311,9 @@
                                           profile->IsOffTheRecord(),
                                           profile->GetPrefs());
 
-  if (browser_context_ && !browser_context_->IsOffTheRecord() &&
+  if (base::FeatureList::IsEnabled(
+          optimization_guide::features::kOptimizationGuideModelExecution) &&
+      browser_context_ && !browser_context_->IsOffTheRecord() &&
       !profile->IsGuestSession()) {
     model_execution_features_controller_ =
         std::make_unique<optimization_guide::ModelExecutionFeaturesController>(
diff --git a/chrome/browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc b/chrome/browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc
index a47aff0..f2d27484 100644
--- a/chrome/browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc
+++ b/chrome/browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc
@@ -160,6 +160,7 @@
     // Enable visibility of tab organization feature.
     scoped_feature_list_.InitWithFeatures(
         {optimization_guide::features::kOptimizationHints,
+         optimization_guide::features::kOptimizationGuideModelExecution,
          optimization_guide::features::internal::
              kTabOrganizationSettingsVisibility},
         {});
@@ -319,6 +320,9 @@
         ->IsSettingVisible(feature);
   }
 
+ protected:
+  base::test::ScopedFeatureList scoped_feature_list_;
+
  private:
   std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
@@ -345,7 +349,6 @@
   std::unique_ptr<network::TestNetworkConnectionTracker>
       network_connection_tracker_;
 
-  base::test::ScopedFeatureList scoped_feature_list_;
   optimization_guide::testing::TestHintsComponentCreator
       test_hints_component_creator_;
   std::unique_ptr<OptimizationGuideConsumerWebContentsObserver> consumer_;
@@ -1193,6 +1196,57 @@
 }
 #endif
 
+// Test the visibility of features with `kOptimizationGuideModelExecution`
+// enabled or disabled.
+class OptimizationGuideKeyedServiceBrowserWithModelExecutionFeatureDisabledTest
+    : public testing::WithParamInterface<bool>,
+      public OptimizationGuideKeyedServiceBrowserTest {
+ public:
+  OptimizationGuideKeyedServiceBrowserWithModelExecutionFeatureDisabledTest()
+      : OptimizationGuideKeyedServiceBrowserTest() {
+    // Enable visibility of tab organization feature.
+    scoped_feature_list_.Reset();
+
+    if (ShouldFeatureBeEnabled()) {
+      scoped_feature_list_.InitWithFeatures(
+          {optimization_guide::features::kOptimizationHints,
+           // Enabled.
+           optimization_guide::features::kOptimizationGuideModelExecution,
+           optimization_guide::features::internal::
+               kTabOrganizationSettingsVisibility},
+          {});
+    } else {
+      scoped_feature_list_.InitWithFeatures(
+          {optimization_guide::features::kOptimizationHints,
+           optimization_guide::features::internal::
+               kTabOrganizationSettingsVisibility},
+          // Disabled.
+          {optimization_guide::features::kOptimizationGuideModelExecution});
+    }
+  }
+
+  bool ShouldFeatureBeEnabled() const { return GetParam(); }
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    All,
+    OptimizationGuideKeyedServiceBrowserWithModelExecutionFeatureDisabledTest,
+    testing::Bool());
+
+IN_PROC_BROWSER_TEST_P(
+    OptimizationGuideKeyedServiceBrowserWithModelExecutionFeatureDisabledTest,
+    SettingsNotVisible) {
+  EnableSignIn();
+
+  EXPECT_FALSE(
+      IsSettingVisible(optimization_guide::proto::ModelExecutionFeature::
+                           MODEL_EXECUTION_FEATURE_WALLPAPER_SEARCH));
+
+  EXPECT_EQ(ShouldFeatureBeEnabled(),
+            IsSettingVisible(optimization_guide::proto::ModelExecutionFeature::
+                                 MODEL_EXECUTION_FEATURE_TAB_ORGANIZATION));
+}
+
 class OptimizationGuideKeyedServicePermissionsCheckDisabledTest
     : public OptimizationGuideKeyedServiceBrowserTest {
  public:
diff --git a/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate.cc b/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate.cc
index 354bb75..d4c3d38 100644
--- a/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate.cc
+++ b/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate.cc
@@ -255,7 +255,10 @@
   const app_restore::RestoreData* full_restore_data =
       full_restore::FullRestoreSaveHandler::GetInstance()->GetRestoreData(
           user_profile->GetPath());
-  DCHECK(full_restore_data);
+  if (!full_restore_data) {
+    std::move(callback).Run({});
+    return;
+  }
 
   const std::string app_id = full_restore::GetAppId(window);
   // TODO: b/296445956 - Implement a long term fix for saving the arc ghost
diff --git a/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate_unittest.cc b/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate_unittest.cc
index 4560a12..9ccb0631 100644
--- a/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate_unittest.cc
+++ b/chrome/browser/ui/ash/desks/chrome_saved_desk_delegate_unittest.cc
@@ -59,7 +59,6 @@
  public:
   MockBrowserManager()
       : BrowserManager(std::unique_ptr<crosapi::BrowserLoader>(), nullptr) {}
-  MOCK_METHOD(bool, IsRunning, (), (const, override));
   MOCK_METHOD(void,
               GetBrowserInformation,
               (const std::string&,
@@ -67,12 +66,6 @@
               (override));
 };
 
-void ReturnEmptyGetBrowserInformation(
-    const std::string& window_unique_id,
-    crosapi::BrowserManager::GetBrowserInformationCallback callback) {
-  // Returns empty lacros browser information.
-  std::move(callback).Run({});
-}
 }  // namespace
 
 class ChromeSavedDeskDelegateTest : public testing::Test {
@@ -132,10 +125,6 @@
     return chrome_saved_desk_delegate_.get();
   }
 
-  content::BrowserTaskEnvironment& task_environment() {
-    return task_environment_;
-  }
-
   MockBrowserManager& mock_browser_manager() { return *mock_browser_manager_; }
 
   full_restore::FullRestoreSaveHandler* GetSaveHandler(
@@ -187,12 +176,6 @@
   // get lacros window information.
   SaveWindowInfo(window.get(), kActivationIndex1);
 
-  EXPECT_CALL(mock_browser_manager(), IsRunning()).WillOnce(Return(true));
-  EXPECT_CALL(mock_browser_manager(), GetBrowserInformation(_, _))
-      .WillOnce(Invoke(ReturnEmptyGetBrowserInformation));
-
-  task_environment().RunUntilIdle();
-
   base::test::TestFuture<std::unique_ptr<app_restore::AppLaunchInfo>> future;
   chrome_saved_desk_delegate()->GetAppLaunchDataForSavedDesk(
       window.get(), future.GetCallback());
diff --git a/chrome/build/android-arm32.pgo.txt b/chrome/build/android-arm32.pgo.txt
index 7f5f616e..0fcca74 100644
--- a/chrome/build/android-arm32.pgo.txt
+++ b/chrome/build/android-arm32.pgo.txt
@@ -1 +1 @@
-chrome-android32-main-1700910362-a857e9a172ed3ee505f32bdf7ae51ed5d2b35b95.profdata
+chrome-android32-main-1700998322-ce6dd7b53f31d6d19151a45fc41ddbf6f0318f55.profdata
diff --git a/chrome/build/android-arm64.pgo.txt b/chrome/build/android-arm64.pgo.txt
index 285dbe1..5b5577ec 100644
--- a/chrome/build/android-arm64.pgo.txt
+++ b/chrome/build/android-arm64.pgo.txt
@@ -1 +1 @@
-chrome-android64-main-1700910362-1d91086723a8334eed79fdde969366318ab242d5.profdata
+chrome-android64-main-1700998322-58eb7f25ad9827c3a024d5402ed823e0e0616a5c.profdata
diff --git a/chrome/build/linux.pgo.txt b/chrome/build/linux.pgo.txt
index e9e7e162..359e8537 100644
--- a/chrome/build/linux.pgo.txt
+++ b/chrome/build/linux.pgo.txt
@@ -1 +1 @@
-chrome-linux-main-1700910362-fc1717e60943e3e89093de0ef98a4e1d0e1abb54.profdata
+chrome-linux-main-1700978206-5768dc024463ee3c26ca94d5df67d5c364ed27f0.profdata
diff --git a/chrome/build/mac-arm.pgo.txt b/chrome/build/mac-arm.pgo.txt
index bb41fa0..2315449 100644
--- a/chrome/build/mac-arm.pgo.txt
+++ b/chrome/build/mac-arm.pgo.txt
@@ -1 +1 @@
-chrome-mac-arm-main-1700920416-580ffb63ebb383e119d9673d74ae3bfe4bc905af.profdata
+chrome-mac-arm-main-1701007083-aed66938e7104fac03aeff85d04c54767f5df9a6.profdata
diff --git a/chrome/build/mac.pgo.txt b/chrome/build/mac.pgo.txt
index 9714d6d..f8107f2 100644
--- a/chrome/build/mac.pgo.txt
+++ b/chrome/build/mac.pgo.txt
@@ -1 +1 @@
-chrome-mac-main-1700910362-068a46e9e5c1d0f1480bf842a48724b7e923cd1d.profdata
+chrome-mac-main-1700998322-d5fcaf23130f97293cedc22a8a3516d478a574cd.profdata
diff --git a/chrome/build/win-arm64.pgo.txt b/chrome/build/win-arm64.pgo.txt
index 6e49672..787f5231 100644
--- a/chrome/build/win-arm64.pgo.txt
+++ b/chrome/build/win-arm64.pgo.txt
@@ -1 +1 @@
-chrome-win-arm64-main-1700910362-38d42641ceb32cc2359e7183c9660bb62cb16b97.profdata
+chrome-win-arm64-main-1700998322-40e76fac3419cd57dcd8bc5abd35a7554aa6ca76.profdata
diff --git a/chrome/build/win32.pgo.txt b/chrome/build/win32.pgo.txt
index 3e9b7252..2f2b110c 100644
--- a/chrome/build/win32.pgo.txt
+++ b/chrome/build/win32.pgo.txt
@@ -1 +1 @@
-chrome-win32-main-1700902363-f30eed405aebc115c98f1b660c6a2d82e9331b77.profdata
+chrome-win32-main-1700998322-144b63df6e5128034c7b548170f0624949e54b39.profdata
diff --git a/chrome/build/win64.pgo.txt b/chrome/build/win64.pgo.txt
index 694e3e3..ce52112 100644
--- a/chrome/build/win64.pgo.txt
+++ b/chrome/build/win64.pgo.txt
@@ -1 +1 @@
-chrome-win64-main-1700902363-aba0e546f170b4c09d986d0c7fc1bc753ff1eb30.profdata
+chrome-win64-main-1700998322-f5d75546e053c4a16b52c241302bc911e5211b77.profdata
diff --git a/chromeos/CHROMEOS_LKGM b/chromeos/CHROMEOS_LKGM
index 0c9e5b48..e7910ca6 100644
--- a/chromeos/CHROMEOS_LKGM
+++ b/chromeos/CHROMEOS_LKGM
@@ -1 +1 @@
-15689.0.0
\ No newline at end of file
+15690.0.0
\ No newline at end of file
diff --git a/chromeos/profiles/arm-exp.afdo.newest.txt b/chromeos/profiles/arm-exp.afdo.newest.txt
index dd44bb7c..9ed9382 100644
--- a/chromeos/profiles/arm-exp.afdo.newest.txt
+++ b/chromeos/profiles/arm-exp.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-arm-exp-121-6126.0-1700479769-benchmark-121.0.6145.0-r1-redacted.afdo.xz
+chromeos-chrome-arm-exp-121-6126.0-1700479769-benchmark-121.0.6148.0-r1-redacted.afdo.xz
diff --git a/chromeos/profiles/arm.afdo.newest.txt b/chromeos/profiles/arm.afdo.newest.txt
index 7c3c3389..0dc19f35 100644
--- a/chromeos/profiles/arm.afdo.newest.txt
+++ b/chromeos/profiles/arm.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-arm-none-121-6099.25-1700484597-benchmark-121.0.6145.0-r1-redacted.afdo.xz
+chromeos-chrome-arm-none-121-6099.25-1700484597-benchmark-121.0.6148.0-r1-redacted.afdo.xz
diff --git a/chromeos/profiles/atom.afdo.newest.txt b/chromeos/profiles/atom.afdo.newest.txt
index 13c6095..f5fc119 100644
--- a/chromeos/profiles/atom.afdo.newest.txt
+++ b/chromeos/profiles/atom.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-atom-121-6126.0-1700479769-benchmark-121.0.6145.0-r1-redacted.afdo.xz
+chromeos-chrome-amd64-atom-121-6126.0-1700479769-benchmark-121.0.6146.0-r1-redacted.afdo.xz
diff --git a/chromeos/profiles/bigcore.afdo.newest.txt b/chromeos/profiles/bigcore.afdo.newest.txt
index eca0946..d909287a 100644
--- a/chromeos/profiles/bigcore.afdo.newest.txt
+++ b/chromeos/profiles/bigcore.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-bigcore-121-6099.25-1700476772-benchmark-121.0.6145.0-r1-redacted.afdo.xz
+chromeos-chrome-amd64-bigcore-121-6099.25-1700476772-benchmark-121.0.6148.0-r1-redacted.afdo.xz
diff --git a/clank b/clank
index bdc4d4d..bd44c4c 160000
--- a/clank
+++ b/clank
@@ -1 +1 @@
-Subproject commit bdc4d4d785d044cf585fb255b69f7283eed1f721
+Subproject commit bd44c4cb90445bd38f361c33924f84a375e17f6f
diff --git a/components/app_restore/lacros_save_handler.cc b/components/app_restore/lacros_save_handler.cc
index c385b7e8..fee16fc 100644
--- a/components/app_restore/lacros_save_handler.cc
+++ b/components/app_restore/lacros_save_handler.cc
@@ -82,6 +82,11 @@
   uint32_t browser_session_id =
       static_cast<uint32_t>(window->GetProperty(app_restore::kWindowIdKey));
 
+  // Ephemeral windows have a`browser_session_id` of 0 by default.
+  if (!browser_session_id) {
+    return;
+  }
+
   auto it = window_candidates_.find(lacros_window_id);
   if (it != window_candidates_.end() &&
       it->second.window_id != browser_session_id) {
diff --git a/components/certificate_transparency/data/log_list.json b/components/certificate_transparency/data/log_list.json
index 1392913..defbcb00 100644
--- a/components/certificate_transparency/data/log_list.json
+++ b/components/certificate_transparency/data/log_list.json
@@ -1,6 +1,6 @@
 {
-  "version": "26.55",
-  "log_list_timestamp": "2023-11-25T12:54:40Z",
+  "version": "27.1",
+  "log_list_timestamp": "2023-11-26T12:54:39Z",
   "operators": [
     {
       "name": "Google",
@@ -47,8 +47,8 @@
           "url": "https://ct.googleapis.com/logs/us1/argon2025h1/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -63,8 +63,8 @@
           "url": "https://ct.googleapis.com/logs/us1/argon2025h2/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -111,8 +111,8 @@
           "url": "https://ct.googleapis.com/logs/eu1/xenon2025h1/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -127,8 +127,8 @@
           "url": "https://ct.googleapis.com/logs/eu1/xenon2025h2/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -326,8 +326,8 @@
           "url": "https://sabre2024h1.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -342,8 +342,8 @@
           "url": "https://sabre2024h2.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -358,8 +358,8 @@
           "url": "https://sabre2025h1.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -374,8 +374,8 @@
           "url": "https://sabre2025h2.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -402,8 +402,8 @@
           "url": "https://mammoth2024h1.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -418,8 +418,8 @@
           "url": "https://mammoth2024h2.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -434,8 +434,8 @@
           "url": "https://mammoth2025h1.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -450,8 +450,8 @@
           "url": "https://mammoth2025h2.ct.sectigo.com/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -522,8 +522,8 @@
           "url": "https://oak.ct.letsencrypt.org/2025h1/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -538,8 +538,8 @@
           "url": "https://oak.ct.letsencrypt.org/2025h2/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -594,8 +594,8 @@
           "url": "https://ct2025-a.trustasia.com/log2025a/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
@@ -610,8 +610,8 @@
           "url": "https://ct2025-b.trustasia.com/log2025b/",
           "mmd": 86400,
           "state": {
-            "qualified": {
-              "timestamp": "2023-09-15T23:09:45Z"
+            "usable": {
+              "timestamp": "2023-11-26T12:00:00Z"
             }
           },
           "temporal_interval": {
diff --git a/components/viz/service/display_embedder/skia_output_device_buffer_queue.cc b/components/viz/service/display_embedder/skia_output_device_buffer_queue.cc
index a169716..0778477 100644
--- a/components/viz/service/display_embedder/skia_output_device_buffer_queue.cc
+++ b/components/viz/service/display_embedder/skia_output_device_buffer_queue.cc
@@ -441,8 +441,18 @@
       // number of fences at the end of each raster task at the ShareImage
       // level is costly. Thus, at this point, the gpu tasks have been
       // dispatched and it's safe to create just a single fence.
-      if (!current_frame_fence)
+      if (!current_frame_fence) {
+        // The GL fence below needs context to be current.
+        //
+        // SkiaOutputSurfaceImpl::SwapBuffers() - one of the methods in the call
+        // stack of to SkiaOutputDeviceBufferQueue::ScheduleOverlays() - used to
+        // schedule a MakeCurrent call. For power consumption and performance
+        // reasons, we delay the call to MakeCurrent 'till it is known to
+        // be needed.
+        context_state_->MakeCurrent(nullptr);
+
         current_frame_fence = gl::GLFence::CreateForGpuFence()->GetGpuFence();
+      }
 
       // Dup the fence - it must be inserted into each shared image before
       // ScopedReadAccess is created.
diff --git a/components/viz/service/display_embedder/skia_output_surface_impl.cc b/components/viz/service/display_embedder/skia_output_surface_impl.cc
index 4d4882b8..ba44f3d6 100644
--- a/components/viz/service/display_embedder/skia_output_surface_impl.cc
+++ b/components/viz/service/display_embedder/skia_output_surface_impl.cc
@@ -751,8 +751,10 @@
       /*is_for_render_pass=*/false, raw_draw_if_possible);
 }
 
-DBG_FLAG_FBOOL("skia_gpu.swap_buffers.force_disable_makecurrent",
-               force_disable_makecurrent)
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+DBG_FLAG_FBOOL("skia_gpu.swap_buffers.force_calling_makecurrent",
+               force_makecurrent)
+#endif
 
 void SkiaOutputSurfaceImpl::SwapBuffers(OutputSurfaceFrame frame) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@@ -780,7 +782,19 @@
   auto callback =
       base::BindOnce(&SkiaOutputSurfaceImplOnGpu::SwapBuffers,
                      base::Unretained(impl_on_gpu_.get()), std::move(frame));
-  bool make_current = !force_disable_makecurrent();
+  bool make_current =
+#if BUILDFLAG(IS_CHROMEOS_LACROS)
+      // Normally we don't need MakeCurrent for SwapBuffers, but it is done
+      // historically and there are edge cases too.
+      // For lacros, we do not call MakeCurrent here, and delay it where
+      // appropriated.
+      //
+      // TODO(crbug.com/1494032): Extend that approach for other platforms.
+      force_makecurrent();  // Defaults to false.
+#else
+      true;
+#endif
+
   EnqueueGpuTask(std::move(callback), std::move(resource_sync_tokens_),
                  make_current,
                  /*need_framebuffer=*/!dependency_->IsOffscreen());
diff --git a/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt b/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
index d240129..054044fe 100644
--- a/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
+++ b/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
@@ -708,10 +708,6 @@
 #####################
 
 
-crbug.com/1446435 [ chromeos lacros-chrome chromeos-board-jacuzzi arm angle-opengles passthrough ] conformance/extensions/angle-instanced-arrays-out-of-bounds.html [ Failure ]
-crbug.com/1446435 [ chromeos lacros-chrome chromeos-board-jacuzzi passthrough ] conformance/glsl/bugs/constant-precision-qualifier.html [ Failure ]
-crbug.com/1446435 [ chromeos lacros-chrome chromeos-board-jacuzzi passthrough ] conformance/limits/gl-max-texture-dimensions.html [ Failure ]
-crbug.com/1446435 [ chromeos lacros-chrome chromeos-board-jacuzzi passthrough ] conformance/misc/shader-precision-format.html [ Failure ]
 crbug.com/1481267 [ chromeos lacros-chrome chromeos-board-octopus passthrough ] conformance/textures/misc/texture-size-limit.html [ Failure ]
 
 ###########################
diff --git a/extensions/strings/extensions_strings_sk.xtb b/extensions/strings/extensions_strings_sk.xtb
index 423ac588..6728488 100644
--- a/extensions/strings/extensions_strings_sk.xtb
+++ b/extensions/strings/extensions_strings_sk.xtb
@@ -8,6 +8,7 @@
 <translation id="1420684932347524586">Generovanie náhodného súkromného kľúča RSA žiaľ zlyhalo.</translation>
 <translation id="1445572445564823378">Toto rozšírenie spomaľuje prehliadač <ph name="PRODUCT_NAME" />. Ak chcete obnoviť výkonnosť prehliadača <ph name="PRODUCT_NAME" />, zakážte ho.</translation>
 <translation id="1468038450257740950">Rozhranie WebGL nie je podporované.</translation>
+<translation id="1610570795592207282">Pre skript sa nepodarilo načítať súbor css „<ph name="RELATIVE_PATH" />“.</translation>
 <translation id="1803557475693955505">Nepodarilo sa načítať stránku na pozadí „<ph name="BACKGROUND_PAGE" />“.</translation>
 <translation id="2159915644201199628">Nepodarilo sa dekódovať obrázok: <ph name="IMAGE_NAME" /></translation>
 <translation id="2350172092385603347">Lokalizácia sa použila, parameter default_locale však nebol v manifeste určený.</translation>
@@ -31,6 +32,7 @@
 <translation id="4988792151665380515">Exportovanie verejného kľúča zlyhalo.</translation>
 <translation id="5026754133087629784">Webview: <ph name="WEBVIEW_TAG_NAME" /></translation>
 <translation id="5098647635849512368">Absolútnu cestu k adresáru na zbalenie nie je možné nájsť.</translation>
+<translation id="5160071981665899014">Pre skript sa nepodarilo načítať súbor javascript „<ph name="RELATIVE_PATH" />“.</translation>
 <translation id="5356315618422219272">Značka appview: <ph name="APPVIEW_TAG_NAME" /></translation>
 <translation id="5436430103864390185">Tvarované okná nie sú podporované.</translation>
 <translation id="5456409301717116725">Toto rozšírenie obsahuje súbor kľúča <ph name="KEY_PATH" />. Pravdepodobne to nechcete urobiť.</translation>
diff --git a/infra/config/generated/testing/variants.pyl b/infra/config/generated/testing/variants.pyl
index b534a93..74845fbe 100644
--- a/infra/config/generated/testing/variants.pyl
+++ b/infra/config/generated/testing/variants.pyl
@@ -70,16 +70,16 @@
   },
   'LACROS_VERSION_SKEW_CANARY': {
     'identifier': 'Lacros version skew testing ash canary',
-    'description': 'Run with ash-chrome version 121.0.6147.0',
+    'description': 'Run with ash-chrome version 121.0.6149.0',
     'args': [
-      '--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome',
+      '--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome',
     ],
     'swarming': {
       'cipd_packages': [
         {
           'cipd_package': 'chromium/testing/linux-ash-chromium/x86_64/ash.zip',
-          'location': 'lacros_version_skew_tests_v121.0.6147.0',
-          'revision': 'version:121.0.6147.0',
+          'location': 'lacros_version_skew_tests_v121.0.6149.0',
+          'revision': 'version:121.0.6149.0',
         },
       ],
     },
diff --git a/infra/config/targets/lacros-version-skew-variants.json b/infra/config/targets/lacros-version-skew-variants.json
index 3aa3ee15..f974e845 100644
--- a/infra/config/targets/lacros-version-skew-variants.json
+++ b/infra/config/targets/lacros-version-skew-variants.json
@@ -1,16 +1,16 @@
 {
   "LACROS_VERSION_SKEW_CANARY": {
     "args": [
-      "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+      "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
     ],
-    "description": "Run with ash-chrome version 121.0.6147.0",
+    "description": "Run with ash-chrome version 121.0.6149.0",
     "identifier": "Lacros version skew testing ash canary",
     "swarming": {
       "cipd_packages": [
         {
           "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-          "location": "lacros_version_skew_tests_v121.0.6147.0",
-          "revision": "version:121.0.6147.0"
+          "location": "lacros_version_skew_tests_v121.0.6149.0",
+          "revision": "version:121.0.6149.0"
         }
       ]
     }
diff --git a/ios/chrome/app/strings/resources/ios_strings_sk.xtb b/ios/chrome/app/strings/resources/ios_strings_sk.xtb
index 2ecb89e9..9765b58 100644
--- a/ios/chrome/app/strings/resources/ios_strings_sk.xtb
+++ b/ios/chrome/app/strings/resources/ios_strings_sk.xtb
@@ -819,6 +819,7 @@
 <translation id="5300589172476337783">Zobraziť</translation>
 <translation id="5317780077021120954">Uložiť</translation>
 <translation id="5318298563956633672">Tento výrobok už sledujete.</translation>
+<translation id="5329451663851195956">Obnovíte potiahnutím nadol.</translation>
 <translation id="5339316356165661760">Zapnúť synchronizáciu</translation>
 <translation id="5345598430982201510">Nikdy nezisťovať zásielky automaticky</translation>
 <translation id="5345660046352249607">{COUNT,plural, =1{Chcete sledovať túto zásielku?}few{Chcete sledovať {COUNT} zásielky?}many{Track {COUNT} Packages?}other{Chcete sledovať {COUNT} zásielok?}}</translation>
diff --git a/ios_internal b/ios_internal
index 48a0c3d..c55e94d 160000
--- a/ios_internal
+++ b/ios_internal
@@ -1 +1 @@
-Subproject commit 48a0c3d37606ddb07e381e1239ac760e88096f1a
+Subproject commit c55e94d4564fb697d3d83fe9fcbafaffce2e139e
diff --git a/net/http/transport_security_state_static.pins b/net/http/transport_security_state_static.pins
index bf3374d..f2671165 100644
--- a/net/http/transport_security_state_static.pins
+++ b/net/http/transport_security_state_static.pins
@@ -43,9 +43,9 @@
 #   hash function for preloaded entries again (we have already done so once).
 #
 
-# Last updated: 2023-11-25 12:54 UTC
+# Last updated: 2023-11-26 12:54 UTC
 PinsListTimestamp
-1700916880
+1701003279
 
 TestSPKI
 sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
diff --git a/net/http/transport_security_state_static_pins.json b/net/http/transport_security_state_static_pins.json
index a86cc95..f4d9ad8 100644
--- a/net/http/transport_security_state_static_pins.json
+++ b/net/http/transport_security_state_static_pins.json
@@ -31,7 +31,7 @@
 // the 'static_spki_hashes' and 'bad_static_spki_hashes' fields in 'pinsets'
 // refer to, and the timestamp at which the pins list was last updated.
 //
-// Last updated: 2023-11-25 12:54 UTC
+// Last updated: 2023-11-26 12:54 UTC
 //
 {
   "pinsets": [
diff --git a/testing/buildbot/chromium.chromiumos.json b/testing/buildbot/chromium.chromiumos.json
index 37147e0..9eb5a07 100644
--- a/testing/buildbot/chromium.chromiumos.json
+++ b/testing/buildbot/chromium.chromiumos.json
@@ -6122,9 +6122,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -6134,8 +6134,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -6272,9 +6272,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.filter;../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -6284,8 +6284,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
diff --git a/testing/buildbot/chromium.coverage.json b/testing/buildbot/chromium.coverage.json
index 4a6724b..ab7bd0b1 100644
--- a/testing/buildbot/chromium.coverage.json
+++ b/testing/buildbot/chromium.coverage.json
@@ -20593,9 +20593,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -20605,8 +20605,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -20743,9 +20743,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.filter;../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -20755,8 +20755,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
diff --git a/testing/buildbot/chromium.fyi.json b/testing/buildbot/chromium.fyi.json
index 55ae3ff..2d6ee910 100644
--- a/testing/buildbot/chromium.fyi.json
+++ b/testing/buildbot/chromium.fyi.json
@@ -43731,9 +43731,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
         },
@@ -43742,8 +43742,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -43881,9 +43881,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.filter;../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
         },
@@ -43892,8 +43892,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -45205,9 +45205,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
         },
@@ -45216,8 +45216,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -45355,9 +45355,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.filter;../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
         },
@@ -45366,8 +45366,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -46065,9 +46065,9 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome"
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
         },
@@ -46076,8 +46076,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
diff --git a/testing/buildbot/chromium.memory.json b/testing/buildbot/chromium.memory.json
index 53f6448e..9781238 100644
--- a/testing/buildbot/chromium.memory.json
+++ b/testing/buildbot/chromium.memory.json
@@ -16312,12 +16312,12 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.filter;../../testing/buildbot/filters/linux-lacros.interactive_ui_tests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome",
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome",
           "--test-launcher-print-test-stdio=always",
           "--combine-ash-logs-on-bots",
           "--asan-symbolize-output"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -16327,8 +16327,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
@@ -16482,12 +16482,12 @@
       {
         "args": [
           "--test-launcher-filter-file=../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.filter;../../testing/buildbot/filters/linux-lacros.lacros_chrome_browsertests.skew.filter",
-          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome",
+          "--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome",
           "--test-launcher-print-test-stdio=always",
           "--combine-ash-logs-on-bots",
           "--asan-symbolize-output"
         ],
-        "description": "Run with ash-chrome version 121.0.6147.0",
+        "description": "Run with ash-chrome version 121.0.6149.0",
         "isolate_profile_data": true,
         "merge": {
           "script": "//testing/merge_scripts/standard_gtest_merge.py"
@@ -16497,8 +16497,8 @@
           "cipd_packages": [
             {
               "cipd_package": "chromium/testing/linux-ash-chromium/x86_64/ash.zip",
-              "location": "lacros_version_skew_tests_v121.0.6147.0",
-              "revision": "version:121.0.6147.0"
+              "location": "lacros_version_skew_tests_v121.0.6149.0",
+              "revision": "version:121.0.6149.0"
             }
           ],
           "dimensions": {
diff --git a/testing/buildbot/variants.pyl b/testing/buildbot/variants.pyl
index b534a93..74845fbe 100644
--- a/testing/buildbot/variants.pyl
+++ b/testing/buildbot/variants.pyl
@@ -70,16 +70,16 @@
   },
   'LACROS_VERSION_SKEW_CANARY': {
     'identifier': 'Lacros version skew testing ash canary',
-    'description': 'Run with ash-chrome version 121.0.6147.0',
+    'description': 'Run with ash-chrome version 121.0.6149.0',
     'args': [
-      '--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6147.0/test_ash_chrome',
+      '--ash-chrome-path-override=../../lacros_version_skew_tests_v121.0.6149.0/test_ash_chrome',
     ],
     'swarming': {
       'cipd_packages': [
         {
           'cipd_package': 'chromium/testing/linux-ash-chromium/x86_64/ash.zip',
-          'location': 'lacros_version_skew_tests_v121.0.6147.0',
-          'revision': 'version:121.0.6147.0',
+          'location': 'lacros_version_skew_tests_v121.0.6149.0',
+          'revision': 'version:121.0.6149.0',
         },
       ],
     },
diff --git a/third_party/angle b/third_party/angle
index 1bdb403..9a70fc9 160000
--- a/third_party/angle
+++ b/third_party/angle
@@ -1 +1 @@
-Subproject commit 1bdb403899f2040a7b816b3261f13a48914d439c
+Subproject commit 9a70fc9046644c2a3b4bb1ea9f0e56fe19473941
diff --git a/third_party/blink/renderer/bindings/core/v8/js_event_handler_for_content_attribute.h b/third_party/blink/renderer/bindings/core/v8/js_event_handler_for_content_attribute.h
index f2bd9801..fcae3137 100644
--- a/third_party/blink/renderer/bindings/core/v8/js_event_handler_for_content_attribute.h
+++ b/third_party/blink/renderer/bindings/core/v8/js_event_handler_for_content_attribute.h
@@ -51,7 +51,7 @@
   // In case of the content scripts, Blink runs script in the main world instead
   // of the isolated world for the content script by design.
   DOMWrapperWorld& GetWorld() const override {
-    return DOMWrapperWorld::MainWorld();
+    return DOMWrapperWorld::MainWorld(isolate_);
   }
 
  private:
diff --git a/third_party/blink/renderer/bindings/core/v8/script_controller.cc b/third_party/blink/renderer/bindings/core/v8/script_controller.cc
index 641d2998..5065659 100644
--- a/third_party/blink/renderer/bindings/core/v8/script_controller.cc
+++ b/third_party/blink/renderer/bindings/core/v8/script_controller.cc
@@ -122,12 +122,12 @@
 }
 
 void ScriptController::DisableEval(const String& error_message) {
-  SetEvalForWorld(DOMWrapperWorld::MainWorld(), false /* allow_eval */,
-                  error_message);
+  SetEvalForWorld(DOMWrapperWorld::MainWorld(GetIsolate()),
+                  false /* allow_eval */, error_message);
 }
 
 void ScriptController::SetWasmEvalErrorMessage(const String& error_message) {
-  SetWasmEvalErrorMessageForWorld(DOMWrapperWorld::MainWorld(),
+  SetWasmEvalErrorMessageForWorld(DOMWrapperWorld::MainWorld(GetIsolate()),
                                   /*allow_eval=*/false, error_message);
 }
 
diff --git a/third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h b/third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h
index 3b720391..ac1843a 100644
--- a/third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h
+++ b/third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h
@@ -91,11 +91,11 @@
   PAINT = 4,
 };
 
-#define ENTER_EMBEDDER_STATE(isolate, frame, state)               \
-  v8::HandleScope scope(isolate);                                 \
-  v8::Local<v8::Context> v8_context =                             \
-      ToV8ContextMaybeEmpty(frame, DOMWrapperWorld::MainWorld()); \
-  v8::EmbedderStateScope embedder_state(                          \
+#define ENTER_EMBEDDER_STATE(isolate, frame, state)                      \
+  v8::HandleScope scope(isolate);                                        \
+  v8::Local<v8::Context> v8_context =                                    \
+      ToV8ContextMaybeEmpty(frame, DOMWrapperWorld::MainWorld(isolate)); \
+  v8::EmbedderStateScope embedder_state(                                 \
       isolate, v8_context, static_cast<v8::EmbedderStateTag>(state));
 
 template <typename CallbackInfo, typename T>
diff --git a/third_party/blink/renderer/core/exported/web_plugin_container_impl.cc b/third_party/blink/renderer/core/exported/web_plugin_container_impl.cc
index a02f1cd3..84cfb2e 100644
--- a/third_party/blink/renderer/core/exported/web_plugin_container_impl.cc
+++ b/third_party/blink/renderer/core/exported/web_plugin_container_impl.cc
@@ -551,8 +551,7 @@
   if (!context || !context->CanExecuteScripts(kNotAboutToExecuteScript))
     return v8::Local<v8::Object>();
 
-  ScriptState* script_state =
-      ToScriptState(context, DOMWrapperWorld::MainWorld());
+  ScriptState* script_state = ToScriptStateForMainWorld(context);
   if (!script_state)
     return v8::Local<v8::Object>();
 
diff --git a/third_party/blink/renderer/core/frame/local_frame.cc b/third_party/blink/renderer/core/frame/local_frame.cc
index 5987aaa..f0603331 100644
--- a/third_party/blink/renderer/core/frame/local_frame.cc
+++ b/third_party/blink/renderer/core/frame/local_frame.cc
@@ -2886,9 +2886,10 @@
   // into the omnibox.  See https://crbug.com/1082900
   NotifyUserActivation(
       mojom::blink::UserActivationNotificationType::kInteraction, false);
-  DomWindow()->GetScriptController().ExecuteJavaScriptURL(
+  auto* window = DomWindow();
+  window->GetScriptController().ExecuteJavaScriptURL(
       url, network::mojom::CSPDisposition::DO_NOT_CHECK,
-      &DOMWrapperWorld::MainWorld());
+      &DOMWrapperWorld::MainWorld(window->GetIsolate()));
 }
 
 void LocalFrame::RequestExecuteScript(
@@ -2905,7 +2906,7 @@
   ExecuteScriptPolicy execute_script_policy;
   CHECK(!IsProvisional());
   if (world_id == DOMWrapperWorld::kMainWorldId) {
-    world = &DOMWrapperWorld::MainWorld();
+    world = &DOMWrapperWorld::MainWorld(ToIsolate(this));
     execute_script_policy =
         ExecuteScriptPolicy::kDoNotExecuteScriptWhenScriptsDisabled;
   } else {
diff --git a/third_party/blink/renderer/core/html/html_document.cc b/third_party/blink/renderer/core/html/html_document.cc
index 37061e49..7674326b 100644
--- a/third_party/blink/renderer/core/html/html_document.cc
+++ b/third_party/blink/renderer/core/html/html_document.cc
@@ -98,7 +98,7 @@
   named_item_counts_.insert(name);
   if (LocalDOMWindow* window = domWindow()) {
     window->GetScriptController()
-        .WindowProxy(DOMWrapperWorld::MainWorld())
+        .WindowProxy(DOMWrapperWorld::MainWorld(window->GetIsolate()))
         ->NamedItemAdded(this, name);
   }
 }
@@ -109,7 +109,7 @@
   named_item_counts_.erase(name);
   if (LocalDOMWindow* window = domWindow()) {
     window->GetScriptController()
-        .WindowProxy(DOMWrapperWorld::MainWorld())
+        .WindowProxy(DOMWrapperWorld::MainWorld(window->GetIsolate()))
         ->NamedItemRemoved(this, name);
   }
 }
diff --git a/third_party/blink/renderer/core/loader/frame_loader.cc b/third_party/blink/renderer/core/loader/frame_loader.cc
index 3714d4c..76e7cc3 100644
--- a/third_party/blink/renderer/core/loader/frame_loader.cc
+++ b/third_party/blink/renderer/core/loader/frame_loader.cc
@@ -1607,9 +1607,10 @@
   // and relying on the number of created window proxies.
   Settings* settings = frame_->GetSettings();
   if (settings && settings->GetForceMainWorldInitialization()) {
+    auto* window = frame_->DomWindow();
     // Forcibly instantiate WindowProxy.
-    frame_->DomWindow()->GetScriptController().WindowProxy(
-        DOMWrapperWorld::MainWorld());
+    window->GetScriptController().WindowProxy(
+        DOMWrapperWorld::MainWorld(window->GetIsolate()));
   }
   frame_->GetIdlenessDetector()->DidDropNavigation();
 }
@@ -1684,7 +1685,8 @@
   LocalDOMWindow* window = frame_->DomWindow();
   if (settings && settings->GetForceMainWorldInitialization()) {
     // Forcibly instantiate WindowProxy, even if script is disabled.
-    window->GetScriptController().WindowProxy(DOMWrapperWorld::MainWorld());
+    window->GetScriptController().WindowProxy(
+        DOMWrapperWorld::MainWorld(window->GetIsolate()));
   }
   probe::DidClearDocumentOfWindowObject(frame_.Get());
   if (!window->CanExecuteScripts(kNotAboutToExecuteScript))
diff --git a/third_party/blink/renderer/core/messaging/message_port.cc b/third_party/blink/renderer/core/messaging/message_port.cc
index 5d7780c4..2f2a5b6 100644
--- a/third_party/blink/renderer/core/messaging/message_port.cc
+++ b/third_party/blink/renderer/core/messaging/message_port.cc
@@ -361,8 +361,7 @@
     // We cannot check `content->GetCurrentWorld()->IsMainWorld()` here, as the
     // v8::Context may still be empty (and hence
     // ExecutionContext::GetCurrentWorld returns null).
-    if (ScriptState* script_state =
-            ToScriptState(context, DOMWrapperWorld::MainWorld())) {
+    if (ScriptState* script_state = ToScriptStateForMainWorld(context)) {
       CHECK(ThreadScheduler::Current());
       if (auto* tracker =
               ThreadScheduler::Current()->GetTaskAttributionTracker()) {
diff --git a/third_party/blink/renderer/core/navigation_api/navigation_api.cc b/third_party/blink/renderer/core/navigation_api/navigation_api.cc
index 14cdd73b..0671c7b 100644
--- a/third_party/blink/renderer/core/navigation_api/navigation_api.cc
+++ b/third_party/blink/renderer/core/navigation_api/navigation_api.cc
@@ -962,7 +962,7 @@
       blink::CaptureSourceLocation(isolate, message, window_);
   ErrorEvent* event = ErrorEvent::Create(
       ToCoreStringWithNullCheck(isolate, message->Get()), std::move(location),
-      value, &DOMWrapperWorld::MainWorld());
+      value, &DOMWrapperWorld::MainWorld(isolate));
   event->SetType(event_type_names::kNavigateerror);
   DispatchEvent(*event);
 
diff --git a/third_party/blink/renderer/core/page/page.cc b/third_party/blink/renderer/core/page/page.cc
index 3a3268f5..acbb1d23 100644
--- a/third_party/blink/renderer/core/page/page.cc
+++ b/third_party/blink/renderer/core/page/page.cc
@@ -851,7 +851,7 @@
         if (auto* window = DynamicTo<LocalDOMWindow>(frame->DomWindow())) {
           // Forcibly instantiate WindowProxy.
           window->GetScriptController().WindowProxy(
-              DOMWrapperWorld::MainWorld());
+              DOMWrapperWorld::MainWorld(window->GetIsolate()));
         }
       }
       break;
diff --git a/third_party/blink/renderer/core/script/detect_javascript_frameworks.cc b/third_party/blink/renderer/core/script/detect_javascript_frameworks.cc
index 9dc8fe4f..15efc675 100644
--- a/third_party/blink/renderer/core/script/detect_javascript_frameworks.cc
+++ b/third_party/blink/renderer/core/script/detect_javascript_frameworks.cc
@@ -341,7 +341,8 @@
   AtomicString detected_ng_version;
   if (!document.documentElement())
     return;
-  DOMDataStore& dom_data_store = DOMWrapperWorld::MainWorld().DomDataStore();
+  DOMDataStore& dom_data_store =
+      DOMWrapperWorld::MainWorld(isolate).DomDataStore();
   for (Element& element :
        ElementTraversal::InclusiveDescendantsOf(*document.documentElement())) {
     CheckAttributeMatches(element, result, detected_ng_version);
diff --git a/third_party/blink/renderer/core/speculation_rules/document_rule_predicate.cc b/third_party/blink/renderer/core/speculation_rules/document_rule_predicate.cc
index 20168e6..106f119 100644
--- a/third_party/blink/renderer/core/speculation_rules/document_rule_predicate.cc
+++ b/third_party/blink/renderer/core/speculation_rules/document_rule_predicate.cc
@@ -186,10 +186,9 @@
     // For each pattern of predicate’s patterns:
     for (const auto& pattern : patterns_) {
       // Match given pattern and href. If the result is not null, return true.
-      if (pattern->test(
-              ToScriptState(execution_context_, DOMWrapperWorld::MainWorld()),
-              MakeGarbageCollected<V8URLPatternInput>(href),
-              ASSERT_NO_EXCEPTION)) {
+      if (pattern->test(ToScriptStateForMainWorld(execution_context_),
+                        MakeGarbageCollected<V8URLPatternInput>(href),
+                        ASSERT_NO_EXCEPTION)) {
         return true;
       }
     }
diff --git a/third_party/blink/renderer/core/trustedtypes/trusted_types_util.cc b/third_party/blink/renderer/core/trustedtypes/trusted_types_util.cc
index 256cdf9..6f759a9 100644
--- a/third_party/blink/renderer/core/trustedtypes/trusted_types_util.cc
+++ b/third_party/blink/renderer/core/trustedtypes/trusted_types_util.cc
@@ -268,8 +268,7 @@
   //   we are not executing a source String, but an already compiled callback
   //   function.
   v8::HandleScope handle_scope(context->GetIsolate());
-  ScriptState::Scope script_state_scope(
-      ToScriptState(context, DOMWrapperWorld::MainWorld()));
+  ScriptState::Scope script_state_scope(ToScriptStateForMainWorld(context));
   ExceptionState exception_state(
       context->GetIsolate(), ExceptionContextType::kUnknown,
       element_name_for_exception, attribute_name_for_exception);
diff --git a/third_party/blink/web_tests/ChromeTestExpectations b/third_party/blink/web_tests/ChromeTestExpectations
index a6f62f4..1f527fc7 100644
--- a/third_party/blink/web_tests/ChromeTestExpectations
+++ b/third_party/blink/web_tests/ChromeTestExpectations
@@ -12,13 +12,8 @@
 external/wpt/webdriver/tests/classic/perform_actions/wheel.py [ Failure ]  # Flaky output
 external/wpt/webdriver/tests/bidi/input/perform_actions/invalid.py [ Failure Timeout ]  # Flaky output
 external/wpt/webdriver/tests/classic/find_element_from_shadow_root/find.py [ Failure Timeout ]  # Flaky output
-external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/frame.py [ Failure ]  # Flaky output
 external/wpt/webdriver/tests/classic/element_click/navigate.py [ Failure ]  # Flaky output
 external/wpt/webdriver/tests/bidi/input/perform_actions/wheel.py [ Failure ]  # Flaky output
-external/wpt/webdriver/tests/bidi/browsing_context/handle_user_prompt/handle_user_prompt.py [ Timeout ]
-external/wpt/webdriver/tests/bidi/browsing_context/navigation_started/navigation_started.py [ Timeout ]
-external/wpt/webdriver/tests/bidi/browsing_context/print/invalid.py [ Timeout ]
-external/wpt/webdriver/tests/bidi/browsing_context/user_prompt_opened/user_prompt_opened.py [ Timeout ]
 external/wpt/webdriver/tests/bidi/network/add_intercept/invalid.py [ Timeout ]
 external/wpt/webdriver/tests/bidi/network/add_intercept/phases.py [ Timeout ]
 external/wpt/webdriver/tests/bidi/network/remove_intercept/remove_intercept.py [ Timeout ]
@@ -28,9 +23,17 @@
 crbug.com/626703 external/wpt/webdriver/tests/bidi/network/add_intercept/phase_auth_required.py [ Timeout ]
 crbug.com/626703 external/wpt/webdriver/tests/bidi/network/auth_required/auth_required.py [ Timeout ]
 external/wpt/webdriver/tests/bidi/network/add_intercept/url_patterns.py [ Timeout ]
+external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/frame.py [ Failure ]  # Flaky output
+external/wpt/webdriver/tests/bidi/browsing_context/handle_user_prompt/handle_user_prompt.py [ Timeout ]
+external/wpt/webdriver/tests/bidi/browsing_context/navigation_started/navigation_started.py [ Timeout ]
+external/wpt/webdriver/tests/bidi/browsing_context/print/invalid.py [ Timeout ]
+external/wpt/webdriver/tests/bidi/browsing_context/user_prompt_opened/user_prompt_opened.py [ Timeout ]
 external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/format.py [ Failure ]
 external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/invalid.py [ Failure ]
 external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/origin.py [ Failure ]
+external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/context.py [ Failure ]
+external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/delta.py [ Failure ]
+external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/invalid.py [ Failure ]
 
 # Chrome specific failures
 crbug.com/1499775 external/wpt/css/css-text/text-transform/text-transform-capitalize-014.html [ Failure Pass ]
diff --git a/third_party/blink/web_tests/TestExpectations b/third_party/blink/web_tests/TestExpectations
index 78552f5..3ee7d7d 100644
--- a/third_party/blink/web_tests/TestExpectations
+++ b/third_party/blink/web_tests/TestExpectations
@@ -7116,5 +7116,5 @@
 crbug.com/1495671 [ Win ] external/wpt/webmessaging/with-ports/020.html [ Failure Pass ]
 
 # Gardener 2023-11-24
-crbug.com/1504652 [ Mac ] external/wpt/long-animation-frame/tentative/loaf-iframe.html [ Timeout Pass ]
+crbug.com/1504652 [ Mac ] external/wpt/long-animation-frame/tentative/loaf-iframe.html [ Pass Timeout ]
 crbug.com/1503086 external/wpt/html/semantics/invokers/invoketarget-on-audio-behavior.tentative.html [ Failure Pass Timeout ]
diff --git a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
index c6f2834..0dae889 100644
--- a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
+++ b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
@@ -103593,7 +103593,7 @@
       ]
      ],
      "xyz-003.html": [
-      "5b99771d1c0a9ee0baec61c514969af80d7350cf",
+      "d9f3326c582343b6ebaf181ba57f4eb2e706bc33",
       [
        null,
        [
@@ -103602,7 +103602,23 @@
          "=="
         ]
        ],
-       {}
+       {
+        "fuzzy": [
+         [
+          null,
+          [
+           [
+            0,
+            1
+           ],
+           [
+            0,
+            18432
+           ]
+          ]
+         ]
+        ]
+       }
       ]
      ],
      "xyz-004.html": [
@@ -103723,7 +103739,7 @@
       ]
      ],
      "xyz-d65-003.html": [
-      "4dc5e127ef20915e8d28cfc4f4d54935ff886b68",
+      "d5e5cda1f16809b1d8c0a22572ae2a316d3a30cb",
       [
        null,
        [
@@ -103732,7 +103748,23 @@
          "=="
         ]
        ],
-       {}
+       {
+        "fuzzy": [
+         [
+          null,
+          [
+           [
+            0,
+            1
+           ],
+           [
+            0,
+            18432
+           ]
+          ]
+         ]
+        ]
+       }
       ]
      ],
      "xyz-d65-004.html": [
@@ -337602,6 +337634,14 @@
        []
       ]
      },
+     "signs-abs-computed-expected.txt": [
+      "3421b47828cce80bffbd8a465bba7d6b5c5e2822",
+      []
+     ],
+     "signs-abs-invalid-expected.txt": [
+      "8c83fbb9da613079bf2a2e0aa3085b68eba8d993",
+      []
+     ],
      "support": {
       "1x1-green.png": [
        "b98ca0ba0a03c580ac339e4a3653539cfa8edc71",
@@ -389405,7 +389445,7 @@
       []
      ],
      "urltestdata.json": [
-      "46248d132331c1d67a04f6992711ae8ab2d3f717",
+      "69767a20db90bf4d6b37fb6ade5cf2ea5d6686be",
       []
      ]
     },
@@ -389498,6 +389538,10 @@
       "b92b53ee45cd98933a3c2fbcf404478eb8f66a06",
       []
      ],
+     "urlpattern-hasregexpgroups-tests.js": [
+      "4be886e4a5390d7d43356d853cc00c7bbb23d361",
+      []
+     ],
      "urlpatterntestdata.json": [
       "058079bb6d17ace15e7cf6505dc966ea2de0ee45",
       []
@@ -390418,7 +390462,7 @@
        []
       ],
       "property-list.js": [
-       "32b857c30ed5852ae8d027219dd473c46a94bc19",
+       "39a92c7498df4902b5502602a796518143ad4d41",
        []
       ],
       "property-types.js": [
@@ -391756,7 +391800,7 @@
      ],
      "bidi": {
       "__init__.py": [
-       "fd2f704d3e5c4e4e26bb8107306012c59085e39a",
+       "9c976d4a674cc2912909695a62014a317cced331",
        []
       ],
       "browsing_context": {
@@ -391772,7 +391816,7 @@
        },
        "capture_screenshot": {
         "__init__.py": [
-         "18f64fb518917f6a5054089338fc4a53967d1fa0",
+         "32d44104d510de8221d43d9c3262cc6b31ae2238",
          []
         ]
        },
@@ -391896,6 +391940,12 @@
          []
         ]
        },
+       "traverse_history": {
+        "__init__.py": [
+         "1227831549182075b71ed81d80161ff639b54f49",
+         []
+        ]
+       },
        "user_prompt_closed": {
         "__init__.py": [
          "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
@@ -399366,7 +399416,7 @@
       ]
      ],
      "Blob-stream.any.js": [
-      "87710a171a9752416f47596f59d2dc6313d9bd34",
+      "453144cac964a627bb2a004d435887b15ddc96d3",
       [
        "FileAPI/blob/Blob-stream.any.html",
        {
@@ -446809,21 +446859,21 @@
        ]
       ],
       "grid-self-baseline-not-applied-if-sizing-cyclic-dependency-001.html": [
-       "723f3d3090299573b4598b44c8d2a83a25947bb4",
+       "d6526d7995cf80c63af5f2f9fc21da502bbd4264",
        [
         null,
         {}
        ]
       ],
       "grid-self-baseline-not-applied-if-sizing-cyclic-dependency-002.html": [
-       "462daece10b8b3541ef29acf39bc6afc9dfd289d",
+       "ad989b98a63ea57419565f1587e4b3f12f97b376",
        [
         null,
         {}
        ]
       ],
       "grid-self-baseline-not-applied-if-sizing-cyclic-dependency-003.html": [
-       "d50263320ce2fd7e5448648c08e7d0a044978488",
+       "3d688ad15f903bbc96c30cf7a58f232029570905",
        [
         null,
         {}
@@ -465573,14 +465623,14 @@
       ]
      ],
      "signs-abs-computed.html": [
-      "9b8ec89e2a98729deadcbb3e07f700c4eaca6372",
+      "73b1e0d1c326673d9e2628efed4f2e716ddf2202",
       [
        null,
        {}
       ]
      ],
      "signs-abs-invalid.html": [
-      "15b058d0c42bade38f083838eaaabadc64410627",
+      "ccb94c21c232ebdc547f818bbbb5c4cd8935ace4",
       [
        null,
        {}
@@ -637488,6 +637538,69 @@
       }
      ]
     ],
+    "urlpattern-hasregexpgroups.any.js": [
+     "33133d2511b065ca94cc5e793066cc8111b4d6e6",
+     [
+      "urlpattern/urlpattern-hasregexpgroups.any.html",
+      {
+       "script_metadata": [
+        [
+         "global",
+         "window,worker"
+        ],
+        [
+         "script",
+         "resources/urlpattern-hasregexpgroups-tests.js"
+        ]
+       ]
+      }
+     ],
+     [
+      "urlpattern/urlpattern-hasregexpgroups.any.serviceworker.html",
+      {
+       "script_metadata": [
+        [
+         "global",
+         "window,worker"
+        ],
+        [
+         "script",
+         "resources/urlpattern-hasregexpgroups-tests.js"
+        ]
+       ]
+      }
+     ],
+     [
+      "urlpattern/urlpattern-hasregexpgroups.any.sharedworker.html",
+      {
+       "script_metadata": [
+        [
+         "global",
+         "window,worker"
+        ],
+        [
+         "script",
+         "resources/urlpattern-hasregexpgroups-tests.js"
+        ]
+       ]
+      }
+     ],
+     [
+      "urlpattern/urlpattern-hasregexpgroups.any.worker.html",
+      {
+       "script_metadata": [
+        [
+         "global",
+         "window,worker"
+        ],
+        [
+         "script",
+         "resources/urlpattern-hasregexpgroups-tests.js"
+        ]
+       ]
+      }
+     ]
+    ],
     "urlpattern.any.js": [
      "7d47d22609bf8eb14386b0363e36b86f77b2780d",
      [
@@ -669559,6 +669672,21 @@
        "websockets/opening-handshake/005.html?wss",
        {}
       ]
+     ],
+     "006.html": [
+      "304069037cce7e4d6906843484a0257337862488",
+      [
+       "websockets/opening-handshake/006.html?default",
+       {
+        "timeout": "long"
+       }
+      ],
+      [
+       "websockets/opening-handshake/006.html?wss",
+       {
+        "timeout": "long"
+       }
+      ]
      ]
     },
     "referrer.any.js": [
@@ -695306,7 +695434,14 @@
          ]
         ],
         "clip.py": [
-         "1916cb9b7fa0a555a977129f041b49227148cb58",
+         "4e37c4714c3ae27e4bb1bfe968cf2d81618b654e",
+         [
+          null,
+          {}
+         ]
+        ],
+        "format.py": [
+         "7401d94a3ecccd23659274243d2dbd1eb0dcdf7c",
          [
           null,
           {}
@@ -695320,7 +695455,14 @@
          ]
         ],
         "invalid.py": [
-         "9eb459afb5d4295f39938c92915f75caf8ef210a",
+         "58481c4e7ad4464f107dc8bb11ad2def93e7c67d",
+         [
+          null,
+          {}
+         ]
+        ],
+        "origin.py": [
+         "7161d3633630caff7a946cf9c2bdb78b9b21ac5d",
          [
           null,
           {}
@@ -695680,6 +695822,29 @@
          ]
         ]
        },
+       "traverse_history": {
+        "context.py": [
+         "7635c0e9ddd8a4413cc5aeb8af4ff4bbe5ae574a",
+         [
+          null,
+          {}
+         ]
+        ],
+        "delta.py": [
+         "05f4d99544fc850d8a9a325fe2e0eed49dbdf768",
+         [
+          null,
+          {}
+         ]
+        ],
+        "invalid.py": [
+         "abb0d69c937d0a052f95431a674a3cfc45914a29",
+         [
+          null,
+          {}
+         ]
+        ]
+       },
        "user_prompt_closed": {
         "user_prompt_closed.py": [
          "68a0eed1922ea8a5520190f7babb85f315719c70",
diff --git a/third_party/blink/web_tests/external/wpt/FileAPI/blob/Blob-stream.any.js b/third_party/blink/web_tests/external/wpt/FileAPI/blob/Blob-stream.any.js
index 87710a1..453144c 100644
--- a/third_party/blink/web_tests/external/wpt/FileAPI/blob/Blob-stream.any.js
+++ b/third_party/blink/web_tests/external/wpt/FileAPI/blob/Blob-stream.any.js
@@ -70,7 +70,18 @@
   await garbageCollect();
   const chunks = await read_all_chunks(stream, { perform_gc: true });
   assert_array_equals(chunks, input_arr);
-}, "Blob.stream() garbage collection of blob shouldn't break stream" +
+}, "Blob.stream() garbage collection of blob shouldn't break stream " +
+      "consumption")
+
+promise_test(async() => {
+  const input_arr = [8, 241, 48, 123, 151];
+  const typed_arr = new Uint8Array(input_arr);
+  let blob = new Blob([typed_arr]);
+  const chunksPromise = read_all_chunks(blob.stream());
+  // It somehow matters to do GC here instead of doing `perform_gc: true`
+  await garbageCollect();
+  assert_array_equals(await chunksPromise, input_arr);
+}, "Blob.stream() garbage collection of stream shouldn't break stream " +
       "consumption")
 
 promise_test(async () => {
diff --git a/third_party/blink/web_tests/external/wpt/css/css-color/xyz-003.html b/third_party/blink/web_tests/external/wpt/css/css-color/xyz-003.html
index 5b99771..d9f3326 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-color/xyz-003.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-color/xyz-003.html
@@ -4,6 +4,7 @@
 <link rel="author" title="Sam Weinig" href="mailto:weinig@apple.com">
 <link rel="help" href="https://drafts.csswg.org/css-color-4/#valdef-color-xyz">
 <link rel="match" href="xyz-003-ref.html">
+<meta name="fuzzy" content="maxDifference=0-1;totalPixels=0-18432">
 <meta name="assert" content="xyz with no alpha">
 <style>
     body { background-color: grey; }
diff --git a/third_party/blink/web_tests/external/wpt/css/css-color/xyz-d65-003.html b/third_party/blink/web_tests/external/wpt/css/css-color/xyz-d65-003.html
index 4dc5e127..d5e5cda 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-color/xyz-d65-003.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-color/xyz-d65-003.html
@@ -4,6 +4,7 @@
 <link rel="author" title="Sam Weinig" href="mailto:weinig@apple.com">
 <link rel="help" href="https://drafts.csswg.org/css-color-4/#valdef-color-xyz">
 <link rel="match" href="xyz-d65-003-ref.html">
+<meta name="fuzzy" content="maxDifference=0-1;totalPixels=0-18432">
 <meta name="assert" content="xyz-d65 with no alpha">
 <style>
     body { background-color: grey; }
diff --git a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-001.html b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-001.html
index 723f3d3..d6526d7 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-001.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-001.html
@@ -17,7 +17,7 @@
   position: relative;
   border: solid;
   text-orientation: sideways;
-  font-family: Ahem;
+  font: 15px/1 Ahem;
 }
 
 .columns { grid-template-columns: 100px 100px; }
@@ -66,27 +66,27 @@
 <div style="height: 200px">
     <pre>min-content-sized rows - items with relative height</pre>
     <div class="inline-grid alignItemsBaseline columns min-content-rows">
-        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="80">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="160"></div>
-        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="80" data-expected-width="200" data-expected-height="25"></div>
+        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="75">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="150"></div>
+        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="75" data-expected-width="200" data-expected-height="25"></div>
     </div>
 </div>
 
 <div style="height: 200px">
     <pre>max-content-sized rows - items with relative height</pre>
     <div class="inline-grid alignItemsBaseline columns max-content-rows">
-        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="80">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="160"></div>
-        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="80" data-expected-width="200" data-expected-height="25"></div>
+        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="75">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="150"></div>
+        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="75" data-expected-width="200" data-expected-height="25"></div>
     </div>
 </div>
 
 <div style="height: 200px">
     <pre>fit-content-sized rows - items with relative height</pre>
     <div class="inline-grid alignItemsBaseline columns fit-content-rows">
-        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="80">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="160"></div>
-        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="80" data-expected-width="200" data-expected-height="25"></div>
+        <div class="firstRowFirstColumn"                   data-offset-x="0"   data-offset-y="0"  data-expected-width="100" data-expected-height="75">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="firstRowSecondColumn height200Percent" data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="150"></div>
+        <div class="autoRowAutoColumnSpanning2 height25"   data-offset-x="0"   data-offset-y="75" data-expected-width="200" data-expected-height="25"></div>
     </div>
 </div>
 
@@ -120,27 +120,27 @@
 <div style="height: 250px">
     <pre>min-content-sized columns - items with relative width</pre>
     <div class="inline-grid justifyItemsBaseline rows min-content-columns">
-        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="80"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="160" data-expected-height="100"></div>
-        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="80" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="75"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="150" data-expected-height="100"></div>
+        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="75" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
     </div>
 </div>
 
 <div style="height: 250px">
     <pre>max-content-sized columns - items with relative width</pre>
     <div class="inline-grid justifyItemsBaseline rows max-content-columns">
-        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="80"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="160" data-expected-height="100"></div>
-        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="80" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="75"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="150" data-expected-height="100"></div>
+        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="75" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
     </div>
 </div>
 
 <div style="height: 250px">
     <pre>fit-content-sized columns - items with relative width</pre>
     <div class="inline-grid justifyItemsBaseline rows fit-content-columns">
-        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="80"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="160" data-expected-height="100"></div>
-        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="80" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+        <div class="firstRowFirstColumn verticalRL"                  data-offset-x="0"  data-offset-y="0"   data-expected-width="75"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+        <div class="secondRowFirstColumn verticalRL width200Percent" data-offset-x="0"  data-offset-y="100" data-expected-width="150" data-expected-height="100"></div>
+        <div class="firstRowSpanning2AutoColumn verticalRL width25"  data-offset-x="75" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
     </div>
 </div>
 
diff --git a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-002.html b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-002.html
index 462daec..ad989b98 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-002.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-002.html
@@ -17,7 +17,7 @@
   position: relative;
   border: solid;
   text-orientation: sideways;
-  font-family: Ahem;
+  font: 15px/1 Ahem;
 }
 
 .columns { grid-template-columns: 100px 100px; }
@@ -60,45 +60,45 @@
 <!-- NOTE: previously this test was asserting some "cyclic" behaviour where an item would switch baseline alignment participation - this is no longer the case per spec. -->
 <pre>auto-sized rows - horizonal grid and verticalLR item - column-axis baseline</pre>
 <div class="inline-grid alignItemsBaseline columns height200">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="97"   data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="137">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="137" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="95"   data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="135">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="135" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>min-content-sized rows - horizonal grid and verticalLR item - column-axis baseline</pre>
 <div class="inline-grid alignItemsBaseline columns min-content-rows">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="59"  data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="99">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="99" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="55"  data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"  data-expected-width="100" data-expected-height="95">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="95" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>max-content-sized rows - horizonal grid and verticalLR item - column-axis baseline</pre>
 <div class="inline-grid alignItemsBaseline columns max-content-rows">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="59"   data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="99">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="99" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="55"   data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="95">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="95" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>fit-content-sized rows - horizonal grid and verticalLR item - column-axis baseline</pre>
 <div class="inline-grid alignItemsBaseline columns fit-content-rows">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="59"   data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="99">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="99" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="55"   data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="95">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="95" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>flex-sized rows - horizonal grid and verticalLR item - column-axis baseline</pre>
 <div class="inline-grid alignItemsBaseline columns flex-rows">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="59"   data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="99">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="99" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="55"   data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="95">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="95" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>max-flex-sized rows - horizonal grid and verticalLR item - column-axis baseline<br>baseline is not applied initially, but orthogonal items force repeating the track sizing and height is not indefinite in that phase.</pre>
 <!-- https://github.com/w3c/csswg-drafts/issues/3046 -->
 <div class="inline-grid alignItemsBaseline columns auto-rows">
-  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="59"   data-expected-width="100" data-expected-height="75">É</div>
-  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="99">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="99" data-expected-width="200" data-expected-height="25"></div>
+  <div class="firstRowFirstColumn bigFont paddingBottom" data-offset-x="0"   data-offset-y="55"   data-expected-width="100" data-expected-height="75">É</div>
+  <div class="firstRowSecondColumn verticalLR"           data-offset-x="100" data-offset-y="0"   data-expected-width="100" data-expected-height="95">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 height25"       data-offset-x="0"   data-offset-y="95" data-expected-width="200" data-expected-height="25"></div>
 </div>
 
 <pre>auto-sized columns - horizontal grid item - row-axis baseline</pre>
@@ -111,37 +111,37 @@
 <pre>min-content-sized columns - horizontal grid item - row-axis baseline</pre>
 <div class="inline-grid justifyItemsBaseline rows min-content-columns">
   <div class="firstRowFirstColumn bigFont verticalLR paddingLeft" data-offset-x="0"  data-offset-y="0"   data-expected-width="75" data-expected-height="100">É</div>
-  <div class="secondRowFirstColumn"                               data-offset-x="35"  data-offset-y="100" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="99" data-offset-y="0"   data-expected-width="25" data-expected-height="200"></div>
+  <div class="secondRowFirstColumn"                               data-offset-x="35"  data-offset-y="100" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="95" data-offset-y="0"   data-expected-width="25" data-expected-height="200"></div>
 </div>
 
 <pre>max-content-sized columns - horizontal grid item - row-axis baseline</pre>
 <div class="inline-grid justifyItemsBaseline rows max-content-columns">
   <div class="firstRowFirstColumn bigFont verticalLR paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>fit-content-sized columns - horizontal grid item - row-axis baseline</pre>
 <div class="inline-grid justifyItemsBaseline rows fit-content-columns">
   <div class="firstRowFirstColumn bigFont verticalLR paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>flex-sized columns - horizontal grid item - row-axis baseline</pre>
 <div class="inline-grid justifyItemsBaseline rows flex-columns">
   <div class="firstRowFirstColumn bigFont verticalLR paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="secondRowFirstColumn"                               data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>max-flex-sized columns - horizontal grid item - row-axis baseline<br>baseline is not applied initially, but orthogonal items force repeating the track sizing and height is not indefinite in that phase.</pre>
 <!-- https://github.com/w3c/csswg-drafts/issues/3046 -->
 <div class="inline-grid justifyItemsBaseline auto-rows max-flex-columns">
   <div class="firstRowFirstColumn bigFont verticalLR paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="50">É</div>
-  <div class="secondRowFirstColumn verticalLR"                    data-offset-x="32"  data-offset-y="50"  data-expected-width="80"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="112" data-offset-y="0"   data-expected-width="25"  data-expected-height="150"></div>
+  <div class="secondRowFirstColumn verticalLR"                    data-offset-x="32"  data-offset-y="50"  data-expected-width="75"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSpanning2AutoColumn width25"                data-offset-x="107" data-offset-y="0"   data-expected-width="25"  data-expected-height="150"></div>
 </div>
 
 <pre>auto-sized rows - verticalLR grid and horizontal item - column-axis baseline</pre>
@@ -154,52 +154,52 @@
 <pre>min-content-sized rows - verticalLR grid and horizontal item - column-axis baseline</pre>
 <div class="inline-grid verticalLR alignItemsBaseline columns min-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="0"  data-offset-y="0"   data-expected-width="75" data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"  data-offset-y="100" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="99" data-offset-y="0"   data-expected-width="25" data-expected-height="200"></div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"  data-offset-y="100" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="95" data-offset-y="0"   data-expected-width="25" data-expected-height="200"></div>
 </div>
 
 <pre>max-content-sized rows - verticalLR grid and horizontal item - column-axis baseline</pre>
 <div class="inline-grid verticalLR alignItemsBaseline columns max-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>fit-content-sized rows - verticalLR grid and horizontal item - column-axis baseline</pre>
 <div class="inline-grid verticalLR alignItemsBaseline columns fit-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>flex-sized rows - verticalLR grid and horizontal item - column-axis baseline</pre>
 <div class="inline-grid verticalLR alignItemsBaseline columns flex-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="0"   data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="416" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="451" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="35"   data-offset-y="100" data-expected-width="390" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="425" data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>max-flex-sized rows - verticalLR grid and horizontal item - column-axis baseline<br>baseline is not applied initially, but orthogonal items force repeating the track sizing and height is not indefinite in that phase.</pre>
 <!-- https://github.com/w3c/csswg-drafts/issues/3046 -->
 <div class="inline-grid verticalLR alignItemsBaseline auto-columns max-flex-rows">
   <div class="firstRowFirstColumn bigFont"        data-offset-x="0"   data-offset-y="0"   data-expected-width="50"  data-expected-height="50">É</div>
-  <div class="firstRowSecondColumn horizontalBT"  data-offset-x="7"  data-offset-y="50"   data-expected-width="80"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25" data-offset-x="87" data-offset-y="0"    data-expected-width="25"  data-expected-height="150"></div>
+  <div class="firstRowSecondColumn horizontalBT"  data-offset-x="7"  data-offset-y="50"   data-expected-width="75"  data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25" data-offset-x="82" data-offset-y="0"    data-expected-width="25"  data-expected-height="150"></div>
 </div>
 
 <pre>auto-sized rows - verticalRL grid and horizontal item - column-axis baseline</pre>
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline columns width200">
-  <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="28" data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="63"  data-offset-y="100" data-expected-width="137" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
-  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="38"   data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
+  <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="30" data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="65"  data-offset-y="100" data-expected-width="135" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="40"   data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
 <pre>min-content-sized rows - verticalRL grid and horizontal item - column-axis baseline</pre>
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline columns min-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="-10" data-offset-y="0"   data-expected-width="75" data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25" data-offset-y="100" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25" data-offset-y="100" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
   <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="0"  data-offset-y="0"   data-expected-width="25" data-expected-height="200"></div>
 </div>
 
@@ -207,7 +207,7 @@
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline columns max-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="-10" data-offset-y="0"   data-expected-width="75"  data-expected-height="100">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="100" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="100" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
   <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="0"   data-offset-y="0"   data-expected-width="25"  data-expected-height="200"></div>
 </div>
 
@@ -215,7 +215,7 @@
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline auto-columns fit-content-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="-10" data-offset-y="0"   data-expected-width="75"  data-expected-height="50">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="50" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="50" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
   <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="0"   data-offset-y="0"   data-expected-width="25"  data-expected-height="150"></div>
 </div>
 
@@ -223,7 +223,7 @@
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline auto-columns flex-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="-10" data-offset-y="0"   data-expected-width="75"  data-expected-height="50">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="50" data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"  data-offset-y="50" data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
   <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="0"   data-offset-y="0"   data-expected-width="25"  data-expected-height="150"></div>
 </div>
 
@@ -231,7 +231,7 @@
 <pre>baseline alignment is not supported, because the RL items do not share an alignment context with the LR items</pre>
 <div class="inline-grid verticalRL alignItemsBaseline auto-columns max-flex-rows">
   <div class="firstRowFirstColumn bigFont paddingLeft" data-offset-x="-10"  data-offset-y="0"   data-expected-width="75"  data-expected-height="50">É</div>
-  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"   data-offset-y="50"  data-expected-width="99" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
+  <div class="firstRowSecondColumn horizontalTB"       data-offset-x="25"   data-offset-y="50"  data-expected-width="95" data-expected-height="100">ÉÉ É ÉÉ ÉÉÉÉ É ÉÉ ÉÉÉ ÉÉ É</div>
   <div class="autoRowAutoColumnSpanning2 width25"      data-offset-x="0"    data-offset-y="0"   data-expected-width="25"  data-expected-height="150"></div>
 </div>
 
diff --git a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-003.html b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-003.html
index d502633..3d688ad1 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-003.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/grid-self-baseline-not-applied-if-sizing-cyclic-dependency-003.html
@@ -19,7 +19,7 @@
   display: inline-grid;
   background: grey;
   text-orientation: sideways;
-  font-family: Ahem;
+  font: 15px/1 Ahem;
 }
 .row { grid: minmax(0px, 1fr) / auto 50px 100px }
 .column { grid: auto 50px 100px / minmax(0px, 1fr); }
diff --git a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed-expected.txt b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed-expected.txt
new file mode 100644
index 0000000..3421b47
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed-expected.txt
@@ -0,0 +1,6 @@
+This is a testharness.js-based test.
+Found 1 FAIL, 0 TIMEOUT, 0 NOTRUN.
+[FAIL] calc((1em + 1px) * (sign(1em - 10px - 10%) + 1)) should be used-value-equivalent to 21px
+  assert_equals: calc((1em + 1px) * (sign(1em - 10px - 10%) + 1)) and 21px serialize to the same thing in used values. expected "21px" but got "42px"
+Harness: the test ran to completion.
+
diff --git a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed.html b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed.html
index 9b8ec89..73b1e0d1 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-computed.html
@@ -47,6 +47,8 @@
 test_math_used('calc(10px + abs(10%))', '20px', {type:'length'});
 test_math_used('abs(-10px)', '10px', {type:'length'});
 test_math_used('abs(-10%)', '10px', {type:'length'});
+// (20px + 1px) * (sign(20px - 10px - 10px) + 1)
+test_math_used('calc((1em + 1px) * (sign(1em - 10px - 10%) + 1))', '21px', {type:'length'});
 
 // Test sign for zero
 test_zero('calc(sign(-0))', {is_negative: true});
diff --git a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid-expected.txt b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid-expected.txt
new file mode 100644
index 0000000..8c83fbb9
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid-expected.txt
@@ -0,0 +1,6 @@
+This is a testharness.js-based test.
+Found 1 FAIL, 0 TIMEOUT, 0 NOTRUN.
+[FAIL] e.style['font-weight'] = "sign(10%)" should not set the property value
+  assert_equals: expected "" but got "sign(10%)"
+Harness: the test ran to completion.
+
diff --git a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid.html b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid.html
index 15b058d..ccb94c2 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-values/signs-abs-invalid.html
@@ -8,7 +8,16 @@
 <script src="../support/parsing-testcommon.js"></script>
 <script>
 function test_invalid_number(value) {
-  test_invalid_value('opacity', value);
+  test_invalid_value('font-weight', value);
+}
+
+function test_invalid_length_percentage(value) {
+  test_invalid_value('margin-left', value);
+  test_invalid_length(value);
+}
+
+function test_invalid_length(value) {
+  test_invalid_value('tab-size', value);
 }
 
 // Syntax checking
@@ -24,6 +33,13 @@
 test_invalid_number('abs(1 2)');
 test_invalid_number('abs(1, , 2)');
 test_invalid_number('abs(1, 2)');
+test_invalid_number('abs(1, 1%)');
+test_invalid_number('abs(1, 0px)');
+test_invalid_number('abs(1, 0s)');
+test_invalid_number('abs(1, 0deg)');
+test_invalid_number('abs(1, 0Hz)');
+test_invalid_number('abs(1, 0dpi)');
+test_invalid_number('abs(1, 0fr)');
 test_invalid_number('sign()');
 test_invalid_number('sign( )');
 test_invalid_number('sign(,)');
@@ -36,6 +52,13 @@
 test_invalid_number('sign(1 2)');
 test_invalid_number('sign(1, , 2)');
 test_invalid_number('sign(1, 2)');
+test_invalid_number('sign(1, 1%)');
+test_invalid_number('sign(1, 0px)');
+test_invalid_number('sign(1, 0s)');
+test_invalid_number('sign(1, 0deg)');
+test_invalid_number('sign(1, 0Hz)');
+test_invalid_number('sign(1, 0dpi)');
+test_invalid_number('sign(1, 0fr)');
 
 // Type checking
 test_invalid_number('abs(0px)');
@@ -44,18 +67,11 @@
 test_invalid_number('abs(0Hz)');
 test_invalid_number('abs(0dpi)');
 test_invalid_number('abs(0fr)');
-test_invalid_number('abs(1, 1%)');
-test_invalid_number('abs(1, 0px)');
-test_invalid_number('abs(1, 0s)');
-test_invalid_number('abs(1, 0deg)');
-test_invalid_number('abs(1, 0Hz)');
-test_invalid_number('abs(1, 0dpi)');
-test_invalid_number('abs(1, 0fr)');
-test_invalid_number('sign(1, 1%)');
-test_invalid_number('sign(1, 0px)');
-test_invalid_number('sign(1, 0s)');
-test_invalid_number('sign(1, 0deg)');
-test_invalid_number('sign(1, 0Hz)');
-test_invalid_number('sign(1, 0dpi)');
-test_invalid_number('sign(1, 0fr)');
-</script>
\ No newline at end of file
+test_invalid_number('abs(1%)');
+test_invalid_number('sign(10px + 5rad)');
+test_invalid_number('sign(10%)');
+test_invalid_length('abs(10%)');
+test_invalid_length('1px * sign(10%)');
+test_invalid_length('1px * sign(1em + 10%)');
+test_invalid_length_percentage('1px * sign(10px + 5rad)');
+</script>
diff --git a/third_party/blink/web_tests/external/wpt/url/resources/urltestdata.json b/third_party/blink/web_tests/external/wpt/url/resources/urltestdata.json
index 46248d1..69767a2 100644
--- a/third_party/blink/web_tests/external/wpt/url/resources/urltestdata.json
+++ b/third_party/blink/web_tests/external/wpt/url/resources/urltestdata.json
@@ -9678,8 +9678,8 @@
     "protocol": "file:",
     "username": "",
     "password": "",
-    "host": "",
-    "hostname": "",
+    "host": "a",
+    "hostname": "a",
     "port": "",
     "pathname": "/",
     "search": "",
diff --git a/third_party/blink/web_tests/external/wpt/web-animations/animation-model/animation-types/property-list.js b/third_party/blink/web_tests/external/wpt/web-animations/animation-model/animation-types/property-list.js
index 32b857c3..39a92c7 100644
--- a/third_party/blink/web_tests/external/wpt/web-animations/animation-model/animation-types/property-list.js
+++ b/third_party/blink/web_tests/external/wpt/web-animations/animation-model/animation-types/property-list.js
@@ -1435,6 +1435,12 @@
     types: [
     ]
   },
+  'view-transition-name': {
+    // https://drafts.csswg.org/css-view-transitions/#propdef-view-transition-name
+    types: [
+      { type: 'discrete', options: [ [ 'none', 'header' ] ] },
+    ]
+  },
   'visibility': {
     // https://drafts.csswg.org/css2/visufx.html#propdef-visibility
     types: [ 'visibility' ]
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/__init__.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/__init__.py
index fd2f704d..9c976d4 100644
--- a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/__init__.py
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/__init__.py
@@ -20,8 +20,9 @@
 
     if type(expected) is dict:
         # Actual dict can have more keys as part of the forwards-compat design.
-        assert expected.keys() <= actual.keys(), \
-            f"Key set should be present: {set(expected.keys()) - set(actual.keys())}"
+        assert (
+            expected.keys() <= actual.keys()
+        ), f"Key set should be present: {set(expected.keys()) - set(actual.keys())}"
         for key in expected.keys():
             recursive_compare(expected[key], actual[key])
         return
@@ -88,7 +89,8 @@
         return window.devicePixelRatio;
     }""",
         target=ContextTarget(context["context"]),
-        await_promise=False)
+        await_promise=False,
+    )
     return result["value"]
 
 
@@ -122,6 +124,22 @@
     return remote_mapping_to_dict(result["value"])
 
 
+async def get_document_dimensions(bidi_session, context: str):
+    expression = """
+        ({
+          height: document.documentElement.scrollHeight,
+          width: document.documentElement.scrollWidth,
+        });
+    """
+    result = await bidi_session.script.evaluate(
+        expression=expression,
+        target=ContextTarget(context["context"]),
+        await_promise=False,
+    )
+
+    return remote_mapping_to_dict(result["value"])
+
+
 def remote_mapping_to_dict(js_object) -> Dict:
     obj = {}
     for key, value in js_object:
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/__init__.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/__init__.py
index 18f64fb5..32d4410 100644
--- a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/__init__.py
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/__init__.py
@@ -1,6 +1,7 @@
 from math import floor
 from ... import (
     get_device_pixel_ratio,
+    get_document_dimensions,
     get_element_dimensions,
     get_viewport_dimensions,
     remote_mapping_to_dict,
@@ -72,6 +73,18 @@
     return (floor(viewport["width"] * dpr), floor(viewport["height"] * dpr))
 
 
+async def get_physical_document_dimensions(bidi_session, context):
+    """Get the physical dimensions of the context's document.
+
+    :param bidi_session: BiDiSession
+    :param context: Browsing context ID
+    :returns: Tuple of (int, int) containing document width, document height.
+    """
+    document = await get_document_dimensions(bidi_session, context)
+    dpr = await get_device_pixel_ratio(bidi_session, context)
+    return (floor(document["width"] * dpr), floor(document["height"] * dpr))
+
+
 async def get_reference_screenshot(bidi_session, inline, context, html):
     """Get the reference screenshot for the given context and html.
 
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/clip.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/clip.py
index 1916cb9b..4e37c47 100644
--- a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/clip.py
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/clip.py
@@ -1,8 +1,12 @@
 import pytest
-from tests.support.image import png_dimensions
+
+import webdriver.bidi.error as error
 from webdriver.bidi.modules.browsing_context import ElementOptions, BoxOptions
 from webdriver.bidi.modules.script import ContextTarget
 
+from tests.support.image import png_dimensions
+
+
 from . import (
     get_element_coordinates,
     get_physical_element_dimensions,
@@ -65,7 +69,7 @@
     assert comparison.equal()
 
 
-async def test_clip_viewport(bidi_session, top_context, inline, compare_png_bidi):
+async def test_clip_box(bidi_session, top_context, inline, compare_png_bidi):
     url = inline("<input>")
     await bidi_session.browsing_context.navigate(
         context=top_context["context"], url=url, wait="complete"
@@ -150,9 +154,7 @@
     assert comparison.equal()
 
 
-async def test_clip_viewport_scroll_to(
-    bidi_session, top_context, inline, compare_png_bidi
-):
+async def test_clip_box_scroll_to(bidi_session, top_context, inline, compare_png_bidi):
     element_styles = "background-color: black; width: 50px; height:50px;"
 
     # Render an element inside of viewport for the reference.
@@ -208,7 +210,7 @@
     assert comparison.equal()
 
 
-async def test_clip_viewport_partially_visible(
+async def test_clip_box_partially_visible(
     bidi_session, top_context, inline, compare_png_bidi
 ):
     viewport_dimensions = await get_viewport_dimensions(bidi_session, top_context)
@@ -259,3 +261,44 @@
 
     comparison = await compare_png_bidi(reference_data, new_data)
     assert comparison.equal()
+
+
+async def test_clip_box_outside_of_window_viewport(bidi_session, top_context):
+    viewport_dimensions = await get_viewport_dimensions(bidi_session, top_context)
+
+    with pytest.raises(error.UnableToCaptureScreenException):
+        await bidi_session.browsing_context.capture_screenshot(
+            context=top_context["context"],
+            clip=BoxOptions(
+                x=viewport_dimensions["width"],
+                y=viewport_dimensions["height"],
+                width=1,
+                height=1,
+            ),
+        )
+
+
+async def test_clip_element_outside_of_window_viewport(
+    bidi_session, top_context, inline
+):
+    viewport_dimensions = await get_viewport_dimensions(bidi_session, top_context)
+
+    element_styles = "background-color: black; width: 50px; height:50px;"
+    # Render element outside of viewport.
+    url = inline(
+        f"""<div style="{element_styles} margin-top: {viewport_dimensions["height"]}px"></div>"""
+    )
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"], url=url, wait="complete"
+    )
+    element = await bidi_session.script.evaluate(
+        await_promise=False,
+        expression="document.querySelector('div')",
+        target=ContextTarget(top_context["context"]),
+    )
+
+    with pytest.raises(error.UnableToCaptureScreenException):
+        await bidi_session.browsing_context.capture_screenshot(
+            context=top_context["context"],
+            clip=ElementOptions(element=element),
+        )
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/format.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/format.py
new file mode 100644
index 0000000..7401d94
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/format.py
@@ -0,0 +1,39 @@
+import pytest
+
+from webdriver.bidi.modules.browsing_context import FormatOptions
+
+
+@pytest.mark.asyncio
+async def test_format_type(bidi_session, top_context, inline):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline("<div style='margin-top:2000px'>foo</div>"),
+        wait="complete")
+
+    png_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"],
+        format=FormatOptions(type="image/png"))
+    jpeg_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"],
+        format=FormatOptions(type="image/jpeg"))
+
+    assert png_screenshot != jpeg_screenshot
+
+
+@pytest.mark.asyncio
+async def test_format_quality(bidi_session, top_context, inline):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline("<div style='margin-top:2000px'>foo</div>"),
+        wait="complete")
+
+    jpeg_quality_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"],
+        format=FormatOptions(type="image/jpeg",quality=0.1))
+    jpeg_high_quality_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"],
+        format=FormatOptions(type="image/jpeg",quality=1))
+
+    assert jpeg_quality_screenshot != jpeg_high_quality_screenshot
+
+    assert len(jpeg_high_quality_screenshot) > len(jpeg_quality_screenshot)
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/invalid.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/invalid.py
index 9eb459a..58481c4e 100644
--- a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/invalid.py
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/invalid.py
@@ -1,9 +1,11 @@
 import pytest
 
-from ... import get_viewport_dimensions
-
 import webdriver.bidi.error as error
-from webdriver.bidi.modules.browsing_context import ElementOptions, BoxOptions
+from webdriver.bidi.modules.browsing_context import (
+    BoxOptions,
+    ElementOptions,
+    FormatOptions,
+)
 from webdriver.bidi.modules.script import ContextTarget
 
 pytestmark = pytest.mark.asyncio
@@ -83,7 +85,7 @@
 
 
 @pytest.mark.parametrize("value", [None, False, "foo", {}, []])
-async def test_params_clip_viewport_x_invalid_type(bidi_session, top_context, value):
+async def test_params_clip_box_x_invalid_type(bidi_session, top_context, value):
     with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
             context=top_context["context"],
@@ -92,7 +94,7 @@
 
 
 @pytest.mark.parametrize("value", [None, False, "foo", {}, []])
-async def test_params_clip_viewport_y_invalid_type(bidi_session, top_context, value):
+async def test_params_clip_box_y_invalid_type(bidi_session, top_context, value):
     with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
             context=top_context["context"],
@@ -101,9 +103,7 @@
 
 
 @pytest.mark.parametrize("value", [None, False, "foo", {}, []])
-async def test_params_clip_viewport_width_invalid_type(
-    bidi_session, top_context, value
-):
+async def test_params_clip_box_width_invalid_type(bidi_session, top_context, value):
     with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
             context=top_context["context"],
@@ -112,9 +112,7 @@
 
 
 @pytest.mark.parametrize("value", [None, False, "foo", {}, []])
-async def test_params_clip_viewport_height_invalid_type(
-    bidi_session, top_context, value
-):
+async def test_params_clip_box_height_invalid_type(bidi_session, top_context, value):
     with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
             context=top_context["context"],
@@ -122,7 +120,7 @@
         )
 
 
-async def test_params_clip_viewport_dimensions_invalid_value(bidi_session, top_context):
+async def test_params_clip_box_dimensions_invalid_value(bidi_session, top_context):
     with pytest.raises(error.UnableToCaptureScreenException):
         await bidi_session.browsing_context.capture_screenshot(
             context=top_context["context"],
@@ -130,44 +128,15 @@
         )
 
 
-async def test_params_clip_viewport_outside_of_window_viewport(
-    bidi_session, top_context
-):
-    viewport_dimensions = await get_viewport_dimensions(bidi_session, top_context)
-
-    with pytest.raises(error.UnableToCaptureScreenException):
+async def test_params_origin_invalid_value(bidi_session, top_context):
+    with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
-            context=top_context["context"],
-            clip=BoxOptions(
-                x=viewport_dimensions["width"],
-                y=viewport_dimensions["height"],
-                width=1,
-                height=1,
-            ),
+            context=top_context["context"], origin="page"
         )
 
 
-async def test_params_clip_element_outside_of_window_viewport(
-    bidi_session, top_context, inline
-):
-    viewport_dimensions = await get_viewport_dimensions(bidi_session, top_context)
-
-    element_styles = "background-color: black; width: 50px; height:50px;"
-    # Render element outside of viewport.
-    url = inline(
-        f"""<div style="{element_styles} margin-top: {viewport_dimensions["height"]}px"></div>"""
-    )
-    await bidi_session.browsing_context.navigate(
-        context=top_context["context"], url=url, wait="complete"
-    )
-    element = await bidi_session.script.evaluate(
-        await_promise=False,
-        expression="document.querySelector('div')",
-        target=ContextTarget(top_context["context"]),
-    )
-
-    with pytest.raises(error.UnableToCaptureScreenException):
+async def test_params_format_invalid_value(bidi_session, top_context):
+    with pytest.raises(error.InvalidArgumentException):
         await bidi_session.browsing_context.capture_screenshot(
-            context=top_context["context"],
-            clip=ElementOptions(element=element),
+            context=top_context["context"], format=FormatOptions(type="image/invalid")
         )
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/origin.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/origin.py
new file mode 100644
index 0000000..7161d36
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/capture_screenshot/origin.py
@@ -0,0 +1,56 @@
+import pytest
+
+from tests.support.image import png_dimensions
+
+from . import get_physical_document_dimensions, get_physical_viewport_dimensions
+
+
+@pytest.mark.asyncio
+async def test_origin(bidi_session, top_context, inline):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline("<div style='margin-top:2000px'>foo</div>"),
+        wait="complete",
+    )
+
+    viewport_dimensions = await get_physical_viewport_dimensions(
+        bidi_session, top_context
+    )
+    document_dimensions = await get_physical_document_dimensions(
+        bidi_session, top_context
+    )
+    assert not viewport_dimensions == document_dimensions
+
+    document_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"], origin="document"
+    )
+    viewport_screenshot = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"], origin="viewport"
+    )
+
+    assert png_dimensions(document_screenshot) == document_dimensions
+    assert png_dimensions(viewport_screenshot) == viewport_dimensions
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("origin", ["document", "viewport"])
+async def test_origin_consistency(bidi_session, top_context, inline, origin):
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline("<div style='margin-top:2000px'>foo</div>"),
+        wait="complete",
+    )
+    screenshot_a = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"], origin=origin
+    )
+
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"],
+        url=inline("<div style='margin-top:2000px'>foo</div>"),
+        wait="complete",
+    )
+    screenshot_b = await bidi_session.browsing_context.capture_screenshot(
+        context=top_context["context"], origin=origin
+    )
+
+    assert screenshot_a == screenshot_b
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/__init__.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/__init__.py
new file mode 100644
index 0000000..12278315
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/__init__.py
@@ -0,0 +1,4 @@
+async def get_url_for_context(bidi_session, context):
+    contexts = await bidi_session.browsing_context.get_tree(root=context)
+
+    return contexts[0]["url"]
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/context.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/context.py
new file mode 100644
index 0000000..7635c0e
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/context.py
@@ -0,0 +1,66 @@
+import pytest
+
+import webdriver.bidi.error as error
+
+from . import get_url_for_context
+
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_params_context_invalid_value(bidi_session):
+    with pytest.raises(error.NoSuchFrameException):
+        await bidi_session.browsing_context.traverse_history(context="foo", delta=1)
+
+
+async def test_top_level_contexts(bidi_session, top_context, new_tab, inline):
+    pages = [
+        inline("<div>page 1</div>"),
+        inline("<div>page 2</div>"),
+    ]
+    for page in pages:
+        for context in [top_context["context"], new_tab["context"]]:
+            await bidi_session.browsing_context.navigate(
+                context=context, url=page, wait="complete"
+            )
+            assert await get_url_for_context(bidi_session, context) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=-1
+    )
+
+    assert await get_url_for_context(bidi_session, top_context["context"]) == pages[1]
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[0]
+
+
+@pytest.mark.parametrize("domain", ["", "alt"], ids=["same_origin", "cross_origin"])
+async def test_iframe(bidi_session, new_tab, inline, domain):
+    iframe_url_1 = inline("page 1")
+    page_url = inline(f"<iframe src='{iframe_url_1}'></iframe>", domain=domain)
+
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=page_url, wait="complete"
+    )
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page_url
+
+    contexts = await bidi_session.browsing_context.get_tree(root=new_tab["context"])
+    iframe_context = contexts[0]["children"][0]
+
+    iframe_url_2 = inline("page 2")
+    await bidi_session.browsing_context.navigate(
+        context=iframe_context["context"], url=iframe_url_2, wait="complete"
+    )
+    assert (
+        await get_url_for_context(bidi_session, iframe_context["context"])
+        == iframe_url_2
+    )
+
+    await bidi_session.browsing_context.traverse_history(
+        context=iframe_context["context"], delta=-1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page_url
+    assert (
+        await get_url_for_context(bidi_session, iframe_context["context"])
+        == iframe_url_1
+    )
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/delta.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/delta.py
new file mode 100644
index 0000000..05f4d99
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/delta.py
@@ -0,0 +1,162 @@
+from pathlib import Path
+
+import pytest
+
+import webdriver.bidi.error as error
+from webdriver.bidi.modules.script import ContextTarget
+
+from . import get_url_for_context
+
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.mark.parametrize("value", [-2, 1])
+async def test_delta_invalid_value(bidi_session, new_tab, inline, value):
+    page = inline("<div>page 1</div>")
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=page, wait="complete"
+    )
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    with pytest.raises(error.NoSuchHistoryEntryException):
+        await bidi_session.browsing_context.traverse_history(
+            context=new_tab["context"], delta=value
+        )
+
+
+async def test_delta_0(bidi_session, new_tab, inline):
+    page = inline("<div>page 1</div>")
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=page, wait="complete"
+    )
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=0
+    )
+
+    # Check that url didn't change
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+
+async def test_delta_forward_and_back(bidi_session, new_tab, inline):
+    pages = [
+        inline("<div>page 1</div>"),
+        inline("<div>page 2</div>"),
+        inline("<div>page 3</div>"),
+    ]
+    for page in pages:
+        await bidi_session.browsing_context.navigate(
+            context=new_tab["context"], url=page, wait="complete"
+        )
+        assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=-2
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[0]
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=2
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[2]
+
+
+async def test_navigate_in_the_same_document(bidi_session, new_tab, url):
+    page_url = "/webdriver/tests/bidi/browsing_context/support/empty.html"
+    pages = [
+        url(page_url),
+        url(page_url + "#foo"),
+        url(page_url + "#bar"),
+    ]
+    for page in pages:
+        await bidi_session.browsing_context.navigate(
+            context=new_tab["context"], url=page, wait="complete"
+        )
+        assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=-1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[1]
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[2]
+
+
+async def test_history_push_state(bidi_session, new_tab, url):
+    page_url = url("/webdriver/tests/bidi/browsing_context/support/empty.html")
+    await bidi_session.browsing_context.navigate(
+        context=new_tab["context"], url=page_url, wait="complete"
+    )
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page_url
+
+    pages = [
+        f"{page_url}#foo",
+        f"{page_url}#bar",
+    ]
+    for page in pages:
+        await bidi_session.script.call_function(
+            function_declaration="""(url) => {
+                history.pushState(null, null, url);
+            }""",
+            arguments=[
+                {"type": "string", "value": page},
+            ],
+            await_promise=False,
+            target=ContextTarget(new_tab["context"]),
+        )
+        assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=-1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[0]
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[1]
+
+
+@pytest.mark.parametrize(
+    "pages",
+    [
+        ["data:text/html,<p>foo</p>", "data:text/html,<p>bar</p>"],
+        [
+            f"{Path(__file__).parents[1].as_uri()}/support/empty.html",
+            f"{Path(__file__).parents[1].as_uri()}/support/other.html",
+        ],
+    ],
+    ids=[
+        "data url",
+        "file url",
+    ],
+)
+async def test_navigate_special_protocols(bidi_session, new_tab, pages):
+    for page in pages:
+        await bidi_session.browsing_context.navigate(
+            context=new_tab["context"], url=page, wait="complete"
+        )
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == page
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=-1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[0]
+
+    await bidi_session.browsing_context.traverse_history(
+        context=new_tab["context"], delta=1
+    )
+
+    assert await get_url_for_context(bidi_session, new_tab["context"]) == pages[1]
diff --git a/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/invalid.py b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/invalid.py
new file mode 100644
index 0000000..abb0d69
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/browsing_context/traverse_history/invalid.py
@@ -0,0 +1,29 @@
+import pytest
+
+import webdriver.bidi.error as error
+
+
+pytestmark = pytest.mark.asyncio
+
+
+MAX_INT = 9007199254740991
+MIN_INT = -MAX_INT
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_context_invalid_type(bidi_session, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.traverse_history(
+            context=value,
+            delta=1
+        )
+
+
+@pytest.mark.parametrize(
+    "value", [None, False, "foo", 1.5, MIN_INT - 1, MAX_INT + 1, {}, []]
+)
+async def test_params_delta_invalid_type(bidi_session, top_context, value):
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.traverse_history(
+            context=top_context["context"], delta=value
+        )
diff --git a/third_party/blink/web_tests/external/wpt/websockets/opening-handshake/006.html b/third_party/blink/web_tests/external/wpt/websockets/opening-handshake/006.html
new file mode 100644
index 0000000..30406903
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/websockets/opening-handshake/006.html
@@ -0,0 +1,58 @@
+<!doctype html>
+<title>WebSockets: Serialized connection attempts</title>
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../constants.sub.js"></script>
+<meta name="variant" content="?default">
+<meta name="variant" content="?wss">
+<div id="log"></div>
+<script>
+async_test(function(t) {
+  const paths = ['/invalid1', '/invalid2', '/invalid3', '/echo']; // /echo is valid
+  let currentTestIndex = 0;
+  let isPreviousConnectionClosed = true;
+
+  function testNextPath() {
+    if (currentTestIndex < paths.length) {
+      t.step(function() {
+        assert_true(isPreviousConnectionClosed, "Previous connection should be closed before attempting a new one");
+        isPreviousConnectionClosed = false;
+
+        const path = paths[currentTestIndex];
+        const ws = new WebSocket(SCHEME_DOMAIN_PORT + path);
+
+        ws.onclose = t.step_func(function(e) {
+          if (path !== '/echo') {
+            assert_false(e.wasClean, "Connection should fail uncleanly for path: " + path);
+          } else {
+            assert_true(e.wasClean, "Connection to /echo should close cleanly");
+          }
+          isPreviousConnectionClosed = true;
+          currentTestIndex++;
+          t.step_timeout(testNextPath, 0); // Schedule the next test
+        });
+
+        ws.onopen = t.step_func(function() {
+          if (path === '/echo') {
+            assert_true(true, "Connection to /echo should succeed");
+            ws.close();
+          } else {
+            t.unreached_func("Invalid path should not succeed");
+          }
+        });
+
+        ws.onerror = t.step_func(function() {
+          if (path === '/echo') {
+            t.unreached_func("Connection to /echo should not encounter an error");
+          } // otherwise failure is expected
+        });
+      });
+    } else {
+      t.done();
+    }
+  }
+
+  testNextPath();
+});
+</script>
diff --git a/third_party/blink/web_tests/flag-specific/highdpi/external/wpt/url/a-element_include=file-expected.txt b/third_party/blink/web_tests/flag-specific/highdpi/external/wpt/url/a-element_include=file-expected.txt
index 756c8f39..3033c411 100644
--- a/third_party/blink/web_tests/flag-specific/highdpi/external/wpt/url/a-element_include=file-expected.txt
+++ b/third_party/blink/web_tests/flag-specific/highdpi/external/wpt/url/a-element_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/linux-chrome/external/wpt/css/css-values/signs-abs-computed-expected.txt b/third_party/blink/web_tests/platform/linux-chrome/external/wpt/css/css-values/signs-abs-computed-expected.txt
new file mode 100644
index 0000000..5b37deb
--- /dev/null
+++ b/third_party/blink/web_tests/platform/linux-chrome/external/wpt/css/css-values/signs-abs-computed-expected.txt
@@ -0,0 +1,4 @@
+This is a testharness.js-based test.
+All subtests passed and are omitted for brevity.
+See https://chromium.googlesource.com/chromium/src/+/HEAD/docs/testing/writing_web_tests.md#Text-Test-Baselines for details.
+Harness: the test ran to completion.
diff --git a/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element-xhtml_include=file-expected.txt b/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element-xhtml_include=file-expected.txt
index 756c8f39..3033c411 100644
--- a/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element-xhtml_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element-xhtml_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element_include=file-expected.txt b/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element_include=file-expected.txt
index 756c8f39..3033c411 100644
--- a/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/linux/external/wpt/url/a-element_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any.worker_include=file-expected.txt b/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
index a859ae0..d30c346 100644
--- a/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any_include=file-expected.txt b/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any_include=file-expected.txt
index a859ae0..d30c346 100644
--- a/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/linux/external/wpt/url/url-constructor.any_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element-xhtml_include=file-expected.txt b/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element-xhtml_include=file-expected.txt
index 756c8f39..3033c411 100644
--- a/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element-xhtml_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element-xhtml_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element_include=file-expected.txt b/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element_include=file-expected.txt
index 756c8f39..3033c411 100644
--- a/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/mac/external/wpt/url/a-element_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any.worker_include=file-expected.txt b/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
index a859ae0..d30c346 100644
--- a/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any_include=file-expected.txt b/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any_include=file-expected.txt
index a859ae0..d30c346 100644
--- a/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/mac/external/wpt/url/url-constructor.any_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 46 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 45 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
   assert_equals: href expected "file:///c:/foo/bar.html" but got "file:///tmp/mock/c:/foo/bar.html"
 [FAIL] Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>
@@ -90,7 +90,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file:///"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/win/external/wpt/url/a-element-xhtml_include=file-expected.txt b/third_party/blink/web_tests/platform/win/external/wpt/url/a-element-xhtml_include=file-expected.txt
index 954c6bed..f2f12b9 100644
--- a/third_party/blink/web_tests/platform/win/external/wpt/url/a-element-xhtml_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/win/external/wpt/url/a-element-xhtml_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 54 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 53 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:/example.com/> against <http://example.org/foo/bar>
   assert_equals: href expected "file:///example.com/" but got "file://example.com/"
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
@@ -106,7 +106,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file://a/"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/win/external/wpt/url/a-element_include=file-expected.txt b/third_party/blink/web_tests/platform/win/external/wpt/url/a-element_include=file-expected.txt
index 954c6bed..f2f12b9 100644
--- a/third_party/blink/web_tests/platform/win/external/wpt/url/a-element_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/win/external/wpt/url/a-element_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 54 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 53 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:/example.com/> against <http://example.org/foo/bar>
   assert_equals: href expected "file:///example.com/" but got "file://example.com/"
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
@@ -106,7 +106,5 @@
   assert_unreached: Expected URL to fail parsing Reached unreachable code
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file://a/"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any.worker_include=file-expected.txt b/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
index 0b771414..15fdff8 100644
--- a/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any.worker_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 54 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 53 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:/example.com/> against <http://example.org/foo/bar>
   assert_equals: href expected "file:///example.com/" but got "file://example.com/"
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
@@ -106,7 +106,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file://a/"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any_include=file-expected.txt b/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any_include=file-expected.txt
index 0b771414..15fdff8 100644
--- a/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any_include=file-expected.txt
+++ b/third_party/blink/web_tests/platform/win/external/wpt/url/url-constructor.any_include=file-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 54 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 53 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] Parsing: <file:/example.com/> against <http://example.org/foo/bar>
   assert_equals: href expected "file:///example.com/" but got "file://example.com/"
 [FAIL] Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>
@@ -106,7 +106,5 @@
   assert_throws_js: function "function() {\n          new URL(expected.input, base);\n        }" did not throw
 [FAIL] Parsing: </\\//\\/a/../> against <file:///>
   assert_equals: href expected "file://////" but got "file://a/"
-[FAIL] Parsing: <//a/../> against <file:///>
-  assert_equals: host expected "" but got "a"
 Harness: the test ran to completion.
 
diff --git a/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-computed-expected.txt b/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-computed-expected.txt
index b9a7406..25213e93 100644
--- a/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-computed-expected.txt
+++ b/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-computed-expected.txt
@@ -1,5 +1,5 @@
 This is a testharness.js-based test.
-Found 204 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 205 FAIL, 0 TIMEOUT, 0 NOTRUN.
 [FAIL] abs(1) should be used-value-equivalent to 1
   assert_not_equals: abs(1) isn't valid in 'z-index'; got the default value instead. got disallowed value "auto"
 [FAIL] sign(1) should be used-value-equivalent to 1
@@ -40,6 +40,8 @@
   assert_not_equals: abs(-10px) isn't valid in 'margin-left'; got the default value instead. got disallowed value "0px"
 [FAIL] abs(-10%) should be used-value-equivalent to 10px
   assert_not_equals: abs(-10%) isn't valid in 'margin-left'; got the default value instead. got disallowed value "0px"
+[FAIL] calc((1em + 1px) * (sign(1em - 10px - 10%) + 1)) should be used-value-equivalent to 21px
+  assert_not_equals: calc((1em + 1px) * (sign(1em - 10px - 10%) + 1)) isn't valid in 'margin-left'; got the default value instead. got disallowed value "0px"
 [FAIL] calc(calc(sign(-0))) should be used-value-equivalent to 0
   assert_not_equals: calc(calc(sign(-0))) isn't valid in 'z-index'; got the default value instead. got disallowed value "auto"
 [FAIL] clamp(-1, calc( 1 / sign(calc(sign(-0)))), 1) should be used-value-equivalent to -1
diff --git a/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-invalid-expected.txt b/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-invalid-expected.txt
new file mode 100644
index 0000000..5b37deb
--- /dev/null
+++ b/third_party/blink/web_tests/virtual/css-sign-related-functions-disabled/external/wpt/css/css-values/signs-abs-invalid-expected.txt
@@ -0,0 +1,4 @@
+This is a testharness.js-based test.
+All subtests passed and are omitted for brevity.
+See https://chromium.googlesource.com/chromium/src/+/HEAD/docs/testing/writing_web_tests.md#Text-Test-Baselines for details.
+Harness: the test ran to completion.
diff --git a/third_party/dawn b/third_party/dawn
index cdfcfca..b268f52 160000
--- a/third_party/dawn
+++ b/third_party/dawn
@@ -1 +1 @@
-Subproject commit cdfcfcabd1400a1552ba7d3c6a92dbb28a83fd76
+Subproject commit b268f525fc231d4f545ae9a40f002b46276bdd17
diff --git a/third_party/devtools-frontend-internal b/third_party/devtools-frontend-internal
index 5884a35..831ddb2 160000
--- a/third_party/devtools-frontend-internal
+++ b/third_party/devtools-frontend-internal
@@ -1 +1 @@
-Subproject commit 5884a35e7f4cccefa590f690f1021d013b8bb06e
+Subproject commit 831ddb26c27ea70c10a67d34ddf4bd41276e667f
diff --git a/third_party/libc++/src b/third_party/libc++/src
index 0ec946f..9e4e987 160000
--- a/third_party/libc++/src
+++ b/third_party/libc++/src
@@ -1 +1 @@
-Subproject commit 0ec946fa26f0ad25ad366e5f7acdec2ab8ceed2a
+Subproject commit 9e4e987c282a170f6daf8b3c8b52d101d2346f68
diff --git a/third_party/skia b/third_party/skia
index 0908f54..7c6b949 160000
--- a/third_party/skia
+++ b/third_party/skia
@@ -1 +1 @@
-Subproject commit 0908f546bfd9e369787d100811fd27d40f09f317
+Subproject commit 7c6b9495b415e59d866df8d10f930b1d34654887
diff --git a/third_party/vulkan-deps b/third_party/vulkan-deps
index 2e96f5c..860dca0 160000
--- a/third_party/vulkan-deps
+++ b/third_party/vulkan-deps
@@ -1 +1 @@
-Subproject commit 2e96f5c2b566dc69b5f30295c85f5e6a19af60e5
+Subproject commit 860dca03b6e71b58e85a6fd261f40e487355008f
diff --git a/third_party/webrtc b/third_party/webrtc
index 5116ad5..2561dd3 160000
--- a/third_party/webrtc
+++ b/third_party/webrtc
@@ -1 +1 @@
-Subproject commit 5116ad58b15b7d56aecc377d06765c3200242b3e
+Subproject commit 2561dd307eaedb9baa8c0cde1fec26d627b777cf
diff --git a/ui/base/x/x11_util.cc b/ui/base/x/x11_util.cc
index a6e8119..2f750c2 100644
--- a/ui/base/x/x11_util.cc
+++ b/ui/base/x/x11_util.cc
@@ -61,61 +61,6 @@
 constexpr int kNetWMStateAdd = 1;
 constexpr int kNetWMStateRemove = 0;
 
-bool SupportsEWMH() {
-  static bool supports_ewmh = false;
-  static bool supports_ewmh_cached = false;
-  if (!supports_ewmh_cached) {
-    supports_ewmh_cached = true;
-
-    x11::Window wm_window = x11::Window::None;
-    if (!x11::Connection::Get()->GetPropertyAs(
-            GetX11RootWindow(), x11::GetAtom("_NET_SUPPORTING_WM_CHECK"),
-            &wm_window)) {
-      supports_ewmh = false;
-      return false;
-    }
-
-    // It's possible that a window manager started earlier in this X session
-    // left a stale _NET_SUPPORTING_WM_CHECK property when it was replaced by a
-    // non-EWMH window manager, so we trap errors in the following requests to
-    // avoid crashes (issue 23860).
-
-    // EWMH requires the supporting-WM window to also have a
-    // _NET_SUPPORTING_WM_CHECK property pointing to itself (to avoid a stale
-    // property referencing an ID that's been recycled for another window), so
-    // we check that too.
-    x11::Window wm_window_property = x11::Window::None;
-    supports_ewmh = x11::Connection::Get()->GetPropertyAs(
-                        wm_window, x11::GetAtom("_NET_SUPPORTING_WM_CHECK"),
-                        &wm_window_property) &&
-                    wm_window_property == wm_window;
-  }
-
-  return supports_ewmh;
-}
-
-bool GetWindowManagerName(std::string* wm_name) {
-  DCHECK(wm_name);
-  if (!SupportsEWMH()) {
-    return false;
-  }
-
-  x11::Window wm_window = x11::Window::None;
-  if (!x11::Connection::Get()->GetPropertyAs(
-          GetX11RootWindow(), x11::GetAtom("_NET_SUPPORTING_WM_CHECK"),
-          &wm_window)) {
-    return false;
-  }
-
-  std::vector<char> str;
-  if (!x11::Connection::Get()->GetArrayProperty(
-          wm_window, x11::GetAtom("_NET_WM_NAME"), &str)) {
-    return false;
-  }
-  wm_name->assign(str.data(), str.size());
-  return true;
-}
-
 // Returns whether the X11 Screen Saver Extension can be used to disable the
 // screen saver.
 bool IsX11ScreenSaverAvailable() {
@@ -412,7 +357,8 @@
 
 bool GetCustomFramePrefDefault() {
   // _NET_WM_MOVERESIZE is needed for frame-drag-initiated window movement.
-  if (!WmSupportsHint(x11::GetAtom("_NET_WM_MOVERESIZE"))) {
+  if (!x11::Connection::Get()->WmSupportsHint(
+          x11::GetAtom("_NET_WM_MOVERESIZE"))) {
     return false;
   }
 
@@ -471,8 +417,8 @@
 }
 
 WindowManagerName GuessWindowManager() {
-  std::string name;
-  if (!GetWindowManagerName(&name)) {
+  std::string name = x11::Connection::Get()->GetWmName();
+  if (name.empty()) {
     return WM_UNNAMED;
   }
   // These names are taken from the WMs' source code.
@@ -546,11 +492,8 @@
 }
 
 std::string GuessWindowManagerName() {
-  std::string name;
-  if (GetWindowManagerName(&name)) {
-    return name;
-  }
-  return "Unknown";
+  std::string name = x11::Connection::Get()->GetWmName();
+  return name.empty() ? "Unknown" : name;
 }
 
 UMALinuxWindowManager GetWindowManagerUMA() {
@@ -611,7 +554,7 @@
   // absence of _NET_WM_STATE_FULLSCREEN in _NET_WM_STATE to determine
   // whether we're fullscreen.
   x11::Atom fullscreen_atom = x11::GetAtom("_NET_WM_STATE_FULLSCREEN");
-  if (WmSupportsHint(fullscreen_atom)) {
+  if (x11::Connection::Get()->WmSupportsHint(fullscreen_atom)) {
     std::vector<x11::Atom> atom_properties;
     if (x11::Connection::Get()->GetArrayProperty(
             window, x11::GetAtom("_NET_WM_STATE"), &atom_properties)) {
@@ -646,21 +589,6 @@
   return true;
 }
 
-bool WmSupportsHint(x11::Atom atom) {
-  if (!SupportsEWMH()) {
-    return false;
-  }
-
-  std::vector<x11::Atom> supported_atoms;
-  if (!x11::Connection::Get()->GetArrayProperty(GetX11RootWindow(),
-                                                x11::GetAtom("_NET_SUPPORTED"),
-                                                &supported_atoms)) {
-    return false;
-  }
-
-  return base::Contains(supported_atoms, atom);
-}
-
 gfx::ICCProfile GetICCProfileForMonitor(int monitor) {
   gfx::ICCProfile icc_profile;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kHeadless)) {
diff --git a/ui/base/x/x11_util.h b/ui/base/x/x11_util.h
index 938b3c1c..d6d83d6 100644
--- a/ui/base/x/x11_util.h
+++ b/ui/base/x/x11_util.h
@@ -234,9 +234,6 @@
 // is called an equal number of times with |suspend| set to false.
 COMPONENT_EXPORT(UI_BASE_X) bool SuspendX11ScreenSaver(bool suspend);
 
-// Returns true if the window manager supports the given hint.
-COMPONENT_EXPORT(UI_BASE_X) bool WmSupportsHint(x11::Atom atom);
-
 // Returns the ICCProfile corresponding to |monitor| using XGetWindowProperty.
 COMPONENT_EXPORT(UI_BASE_X)
 gfx::ICCProfile GetICCProfileForMonitor(int monitor);
diff --git a/ui/chromeos/translations/ui_chromeos_strings_af.xtb b/ui/chromeos/translations/ui_chromeos_strings_af.xtb
index 9e753e2..347d4c7 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_af.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_af.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Gekoppel, geen internet nie</translation>
 <translation id="8965697826696209160">Daar is nie genoeg spasie nie.</translation>
 <translation id="8970887620466824814">Iets is fout.</translation>
+<translation id="8971742885766657349">Sinkronisering – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Chinees- (tradisioneel) Pinjin</translation>
 <translation id="8998871447376656508">Daar is nie genoeg spasie in jou Google Drive beskikbaar om die oplaai te voltooi nie.</translation>
 <translation id="9003940392834790328">Netwerk <ph name="NETWORK_INDEX" /> van <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, seinsterkte <ph name="SIGNAL_STRENGTH" />%, deur jou administrateur bestuur, besonderhede</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_am.xtb b/ui/chromeos/translations/ui_chromeos_strings_am.xtb
index 6704e4a..5024176 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_am.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_am.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">ተገናኝቷል፣ ምንም በይነመረብ የለም</translation>
 <translation id="8965697826696209160">በቂ ቦታ የለም።</translation>
 <translation id="8970887620466824814">የሆነ ችግር ተፈጥሯል።</translation>
+<translation id="8971742885766657349">በማስመር ላይ - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">የቻይንኛ (ተለምዷዊ) ፒንዪን</translation>
 <translation id="8998871447376656508">ሰቀላውን ለማጠናቀቅ በእርስዎ Google Drive ውስጥ በቂ ቦታ የለም።</translation>
 <translation id="9003940392834790328">አውታረ መረብ <ph name="NETWORK_INDEX" /> ከ<ph name="NETWORK_COUNT" />፣ <ph name="NETWORK_NAME" />፣ <ph name="CONNECTION_STATUS" />፣ የሲግናል ጥንካሬ <ph name="SIGNAL_STRENGTH" />%፣ በአስተዳዳሪ የሚተዳደር፣ ዝርዝሮች</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_ar.xtb b/ui/chromeos/translations/ui_chromeos_strings_ar.xtb
index 41e335e..e7443cd 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_ar.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_ar.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">تم الاتصال بالشبكة ولكنها غير متصلة بالإنترنت.</translation>
 <translation id="8965697826696209160">ليست هناك مساحة كافية.</translation>
 <translation id="8970887620466824814">حدث خطأ.</translation>
+<translation id="8971742885766657349">جارٍ المزامنة - ‫%<ph name="PERCENT" /></translation>
 <translation id="8997962250644902079">‏الصينية (التقليدية) باستخدام لوحة مفاتيح Pinyin</translation>
 <translation id="8998871447376656508">‏لا تتوفّر مساحة كافية في Google Drive لإكمال التحميل.</translation>
 <translation id="9003940392834790328">الشبكة <ph name="NETWORK_INDEX" /> من <ph name="NETWORK_COUNT" />، الشبكة <ph name="NETWORK_NAME" />، حالة الاتصال <ph name="CONNECTION_STATUS" />، قوة الإشارة <ph name="SIGNAL_STRENGTH" />%، يديرها المشرف، التفاصيل</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_as.xtb b/ui/chromeos/translations/ui_chromeos_strings_as.xtb
index 277d3f1..eacc5786 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_as.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_as.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">সংযোজিত, ইণ্টাৰনেট নাই</translation>
 <translation id="8965697826696209160">পৰ্যাপ্ত খালী ঠাই নাই।</translation>
 <translation id="8970887620466824814">কিবা ভুল হ’ল।</translation>
+<translation id="8971742885766657349">ছিংক কৰি থকা হৈছে - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">চীনা (পৰম্পৰাগত) পিনয়িন</translation>
 <translation id="8998871447376656508">আপল'ডটো সম্পূৰ্ণ কৰিবলৈ আপোনাৰ Google Driveত পৰ্যাপ্ত পৰিমাণৰ খালী ঠাই নাই।</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_COUNT" />টা নেটৱৰ্কৰ <ph name="NETWORK_INDEX" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, ছিগনেলৰ ক্ষমতা <ph name="SIGNAL_STRENGTH" />%, আপোনাৰ প্ৰশাসকে পৰিচালনা কৰে, সবিশেষ</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_az.xtb b/ui/chromeos/translations/ui_chromeos_strings_az.xtb
index cbd81664..7c1da34 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_az.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_az.xtb
@@ -1039,6 +1039,7 @@
 <translation id="8949925099261528566">Qoşuludur, internet yoxdur</translation>
 <translation id="8965697826696209160">Yer çatmır.</translation>
 <translation id="8970887620466824814">Xəta baş verdi.</translation>
+<translation id="8971742885766657349">Sinxronlaşdırılır - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Çin dili (Ənənəvi) Pinyin</translation>
 <translation id="8998871447376656508">Yükləməni tamamlamaq üçün Google Diskinizdə kifayət qədər boş yer yoxdur.</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_INDEX" />/<ph name="NETWORK_COUNT" /> şəbəkə, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, Siqnal Gücü <ph name="SIGNAL_STRENGTH" />%, Administratorunuz tərəfindən idarə olunur, Detallar</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_be.xtb b/ui/chromeos/translations/ui_chromeos_strings_be.xtb
index 997b851..7cf4490 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_be.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_be.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Падключана, доступу да інтэрнэту няма</translation>
 <translation id="8965697826696209160">Недастаткова месца.</translation>
 <translation id="8970887620466824814">Нешта пайшло не так.</translation>
+<translation id="8971742885766657349">Сінхранізацыя: <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Кітайская (традыцыйная, піньінь)</translation>
 <translation id="8998871447376656508">Не ўдалося завяршыць запампоўванне: на Google Дыску недастаткова свабоднага месца.</translation>
 <translation id="9003940392834790328">Сетка <ph name="NETWORK_INDEX" /> з <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, магутнасць сігналу – <ph name="SIGNAL_STRENGTH" />%, знаходзіцца пад кіраваннем адміністратара, падрабязныя звесткі</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_bg.xtb b/ui/chromeos/translations/ui_chromeos_strings_bg.xtb
index 28abf9d..414079c 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_bg.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_bg.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Установена е връзка – няма достъп до интернет</translation>
 <translation id="8965697826696209160">Няма достатъчно място.</translation>
 <translation id="8970887620466824814">Нещо се обърка.</translation>
+<translation id="8971742885766657349">Синхронизиране – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Китайски (традиционен, пинин)</translation>
 <translation id="8998871447376656508">Няма достатъчно свободно място в Google Диск за завършване на качването.</translation>
 <translation id="9003940392834790328">Мрежа <ph name="NETWORK_INDEX" /> от <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, сила на сигнала <ph name="SIGNAL_STRENGTH" />%, управлява се от администратора ви, подробности</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_bn.xtb b/ui/chromeos/translations/ui_chromeos_strings_bn.xtb
index 6ab9cf6..abf1362 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_bn.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_bn.xtb
@@ -1040,6 +1040,7 @@
 <translation id="8949925099261528566">কানেক্ট করা আছে, ইন্টারনেট নেই</translation>
 <translation id="8965697826696209160">সেখানে যথেষ্ট স্থান নেই৷</translation>
 <translation id="8970887620466824814">কিছু সমস্যা হয়েছে।</translation>
+<translation id="8971742885766657349">সিঙ্ক করা হচ্ছে - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">চীনা (ঐতিহ্যবাহী) পিনইন</translation>
 <translation id="8998871447376656508">আপলোড সম্পূর্ণ করার জন্য আপনার Google Drive-এ পর্যাপ্ত ফ্রি স্পেস নেই।</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_COUNT" />টির মধ্যে <ph name="NETWORK_INDEX" /> নম্বর নেটওয়ার্ক, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, সিগন্যাল: <ph name="SIGNAL_STRENGTH" />%, আপনার অ্যাডমিনিস্ট্রেটর ম্যানেজ করে, বিবরণ</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_bs.xtb b/ui/chromeos/translations/ui_chromeos_strings_bs.xtb
index 38fce76..7acca02 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_bs.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_bs.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Povezano, nema internetske veze</translation>
 <translation id="8965697826696209160">Nema dovoljno prostora.</translation>
 <translation id="8970887620466824814">Nešto nije uredu.</translation>
+<translation id="8971742885766657349">Sinhroniziranje – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">kineski (tradicionalni) pinyin</translation>
 <translation id="8998871447376656508">Na vašem Google Disku nema dovoljno prostora da se dovrši otpremanje.</translation>
 <translation id="9003940392834790328">Mreža <ph name="NETWORK_INDEX" /> od <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, jačina signala <ph name="SIGNAL_STRENGTH" />%, upravlja vaš administrator, detalji</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_de.xtb b/ui/chromeos/translations/ui_chromeos_strings_de.xtb
index 2e05dc1e..bf62b918 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_de.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_de.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Verbunden, kein Internet</translation>
 <translation id="8965697826696209160">Nicht genügend Speicherplatz.</translation>
 <translation id="8970887620466824814">Es gab ein Problem.</translation>
+<translation id="8971742885766657349">Wird synchronisiert – <ph name="PERCENT" /> %</translation>
 <translation id="8997962250644902079">Chinesisch (traditionell) (Pinyin)</translation>
 <translation id="8998871447376656508">In deinem Google Drive ist nicht genügend freier Speicherplatz vorhanden, um den Upload abzuschließen.</translation>
 <translation id="9003940392834790328">Netzwerk <ph name="NETWORK_INDEX" /> von <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, Signalstärke bei <ph name="SIGNAL_STRENGTH" /> %, von deinem Administrator verwaltet, Details</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_en-GB.xtb b/ui/chromeos/translations/ui_chromeos_strings_en-GB.xtb
index 4c07555..a75c5c4 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_en-GB.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_en-GB.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Connected, no Internet</translation>
 <translation id="8965697826696209160">There is not enough space.</translation>
 <translation id="8970887620466824814">Something went wrong.</translation>
+<translation id="8971742885766657349">Syncing – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Chinese (Traditional) Pinyin</translation>
 <translation id="8998871447376656508">There is not enough free space in your Google Drive to complete the upload.</translation>
 <translation id="9003940392834790328">Network <ph name="NETWORK_INDEX" /> of <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, signal strength <ph name="SIGNAL_STRENGTH" />%, managed by your administrator, details</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_es-419.xtb b/ui/chromeos/translations/ui_chromeos_strings_es-419.xtb
index 7ac077f..91f80b2 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_es-419.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_es-419.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Conectado, pero sin conexión a Internet</translation>
 <translation id="8965697826696209160">No hay suficiente espacio.</translation>
 <translation id="8970887620466824814">Se produjo un error</translation>
+<translation id="8971742885766657349">Sincronizando <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Chino tradicional (Pinyin)</translation>
 <translation id="8998871447376656508">No hay suficiente espacio libre en Google Drive para completar la carga.</translation>
 <translation id="9003940392834790328">Red <ph name="NETWORK_INDEX" /> de <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, intensidad de la señal: <ph name="SIGNAL_STRENGTH" />%, administrada por tu administrador, detalles</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_fil.xtb b/ui/chromeos/translations/ui_chromeos_strings_fil.xtb
index d6f5b37..aca078c 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_fil.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_fil.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Nakakonekta, walang internet</translation>
 <translation id="8965697826696209160">Walang sapat na espasyo.</translation>
 <translation id="8970887620466824814">Nagkaproblema.</translation>
+<translation id="8971742885766657349">Nagsi-sync - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Chinese (Traditional) Pinyin</translation>
 <translation id="8998871447376656508">Walang sapat na bakanteng espasyo sa iyong Google Drive para makumpleto ang pag-upload.</translation>
 <translation id="9003940392834790328">Network <ph name="NETWORK_INDEX" /> sa <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, Lakas ng Signal <ph name="SIGNAL_STRENGTH" />%, Pinapamahalaan ng iyong Administrator, Mga Detalye</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_fr-CA.xtb b/ui/chromeos/translations/ui_chromeos_strings_fr-CA.xtb
index e5ac89b..4810824 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_fr-CA.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_fr-CA.xtb
@@ -1043,6 +1043,7 @@
 <translation id="8949925099261528566">Connecté, aucun accès Internet</translation>
 <translation id="8965697826696209160">Il n'y a pas suffisamment d'espace.</translation>
 <translation id="8970887620466824814">Une erreur s'est produite.</translation>
+<translation id="8971742885766657349">Synchronisation en cours… – <ph name="PERCENT" /> %</translation>
 <translation id="8997962250644902079">Chinois (traditionnel, Pinyin)</translation>
 <translation id="8998871447376656508">Il n'y a pas assez d'espace libre dans votre Google Disque pour terminer le téléversement.</translation>
 <translation id="9003940392834790328">Réseau <ph name="NETWORK_INDEX" /> sur <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, force du signal : <ph name="SIGNAL_STRENGTH" /> %, géré par votre administrateur, détails</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_hi.xtb b/ui/chromeos/translations/ui_chromeos_strings_hi.xtb
index 307ba34..e5d44e88 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_hi.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_hi.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">कनेक्ट हो गया, लेकिन इंटरनेट नहीं है</translation>
 <translation id="8965697826696209160">काफ़ी स्थान नहीं है.</translation>
 <translation id="8970887620466824814">कुछ गड़बड़ी हुई.</translation>
+<translation id="8971742885766657349">सिंक हो रहा है - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">चाइनीज़ (परंपरागत) पिनयिन</translation>
 <translation id="8998871447376656508">अपलोड को पूरा करने के लिए, आपके Google Drive में ज़रूरत के मुताबिक खाली जगह नहीं है.</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_COUNT" /> में से <ph name="NETWORK_INDEX" /> नेटवर्क, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, सिग्नल की क्षमता <ph name="SIGNAL_STRENGTH" />%, आपका एडमिन प्रबंधित करता है, जानकारी</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_hr.xtb b/ui/chromeos/translations/ui_chromeos_strings_hr.xtb
index 2c746d35..e2e8a82 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_hr.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_hr.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Povezano, bez interneta</translation>
 <translation id="8965697826696209160">Nema dovoljno prostora.</translation>
 <translation id="8970887620466824814">Nešto nije u redu.</translation>
+<translation id="8971742885766657349">Sinkronizacija – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">kineski (tradicionalni) pinyin</translation>
 <translation id="8998871447376656508">Nema dovoljno slobodnog prostora na Google disku da biste dovršili prijenos.</translation>
 <translation id="9003940392834790328">Mreža <ph name="NETWORK_INDEX" /> od <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, jačina signala <ph name="SIGNAL_STRENGTH" />%, upravlja administrator, pojedinosti</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_hu.xtb b/ui/chromeos/translations/ui_chromeos_strings_hu.xtb
index 3b9f09d9..951287a 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_hu.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_hu.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Csatlakozva, nincs internet-hozzáférés</translation>
 <translation id="8965697826696209160">Nincs elég tárhely.</translation>
 <translation id="8970887620466824814">Hiba történt.</translation>
+<translation id="8971742885766657349">Szinkronizálás – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">kínai (hagyományos) pinjin</translation>
 <translation id="8998871447376656508">Nincs elég szabad tárhelye a Google Drive-on a feltöltés befejezéséhez.</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_INDEX" />. hálózat (összesen <ph name="NETWORK_COUNT" />), <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, jelerősség: <ph name="SIGNAL_STRENGTH" />%, a rendszergazdája kezeli, részletek</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_hy.xtb b/ui/chromeos/translations/ui_chromeos_strings_hy.xtb
index 84cdc5ab..7a6a5c73 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_hy.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_hy.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Միացած է, սակայն ինտերնետ կապ չկա</translation>
 <translation id="8965697826696209160">Բավարար տարածք չկա:</translation>
 <translation id="8970887620466824814">Սխալ առաջացավ:</translation>
+<translation id="8971742885766657349">Համաժամացում – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">չինարեն փինյին (ավանդական)</translation>
 <translation id="8998871447376656508">Վերբեռնումն ավարտելու համար ձեր Google Drive-ում բավարար ազատ տարածք չկա։</translation>
 <translation id="9003940392834790328">Ցանց <ph name="NETWORK_INDEX" />՝ <ph name="NETWORK_COUNT" />-ից, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, ազդանշանի ուժգնությունը՝ <ph name="SIGNAL_STRENGTH" />%, կառավարվում է ձեր ադմինիստրատորի կողմից, մանրամասներ</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_id.xtb b/ui/chromeos/translations/ui_chromeos_strings_id.xtb
index 5ad6907..57ab828 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_id.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_id.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Terhubung, tidak ada internet</translation>
 <translation id="8965697826696209160">Ruang tidak cukup.</translation>
 <translation id="8970887620466824814">Terjadi error.</translation>
+<translation id="8971742885766657349">Menyinkronkan - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Pinyin (Aksara Tradisional) China</translation>
 <translation id="8998871447376656508">Ruang penyimpanan di Google Drive tidak cukup untuk menyelesaikan upload.</translation>
 <translation id="9003940392834790328">Jaringan <ph name="NETWORK_INDEX" /> dari <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, Kekuatan Sinyal <ph name="SIGNAL_STRENGTH" />%, Dikelola oleh Administrator Anda, Detail</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_is.xtb b/ui/chromeos/translations/ui_chromeos_strings_is.xtb
index cff84ec..aebab5ff 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_is.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_is.xtb
@@ -1046,6 +1046,7 @@
 <translation id="8949925099261528566">Tengt, enginn netaðgangur</translation>
 <translation id="8965697826696209160">Ekki er nægilegt pláss.</translation>
 <translation id="8970887620466824814">Eitthvað fór úrskeiðis.</translation>
+<translation id="8971742885766657349">Samstillir – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Kínverska (hefðbundin) Pinyin</translation>
 <translation id="8998871447376656508">Ekki er nægt pláss á Google Drive til að ljúka við upphleðsluna.</translation>
 <translation id="9003940392834790328">Netkerfi <ph name="NETWORK_INDEX" /> af <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, <ph name="SIGNAL_STRENGTH" />% sendistyrkur, stjórnað af kerfisstjóra, upplýsingar</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_it.xtb b/ui/chromeos/translations/ui_chromeos_strings_it.xtb
index a5edcad9..a8c80c65 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_it.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_it.xtb
@@ -1040,6 +1040,7 @@
 <translation id="8949925099261528566">Connesso, senza Internet</translation>
 <translation id="8965697826696209160">Spazio insufficiente.</translation>
 <translation id="8970887620466824814">C'è stato un problema.</translation>
+<translation id="8971742885766657349">Sincronizzazione: <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Cinese (tradizionale) Pinyin</translation>
 <translation id="8998871447376656508">Spazio libero su Google Drive non sufficiente per completare il caricamento.</translation>
 <translation id="9003940392834790328">Rete <ph name="NETWORK_INDEX" /> di <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, intensità del segnale <ph name="SIGNAL_STRENGTH" />%, gestita dall'amministratore, dettagli</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_iw.xtb b/ui/chromeos/translations/ui_chromeos_strings_iw.xtb
index 7736538..f3a511d 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_iw.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_iw.xtb
@@ -1042,6 +1042,7 @@
 <translation id="8949925099261528566">יש חיבור, אין אינטרנט</translation>
 <translation id="8965697826696209160">אין מספיק שטח.</translation>
 <translation id="8970887620466824814">משהו השתבש.</translation>
+<translation id="8971742885766657349">מתבצע סנכרון – <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">‏סינית (מסורתית) Pinyin</translation>
 <translation id="8998871447376656508">‏אין מספיק מקום פנוי ב-Google Drive כדי להשלים את ההעלאה.</translation>
 <translation id="9003940392834790328">‏רשת <ph name="NETWORK_INDEX" /> מתוך <ph name="NETWORK_COUNT" />,‏ <ph name="NETWORK_NAME" />,‏ <ph name="CONNECTION_STATUS" />, עוצמת האות: ‎<ph name="SIGNAL_STRENGTH" />%‎, הרשת מנוהלת על ידי מנהל המערכת שלך, פרטים</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_ja.xtb b/ui/chromeos/translations/ui_chromeos_strings_ja.xtb
index d1b5a05..3cc0f4b 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_ja.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_ja.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">接続済み、インターネット接続なし</translation>
 <translation id="8965697826696209160">空き容量が不足しています。</translation>
 <translation id="8970887620466824814">エラーが発生しました。</translation>
+<translation id="8971742885766657349">同期しています - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">中国語（繁体）（ピンイン）</translation>
 <translation id="8998871447376656508">Google ドライブに十分な空き容量がないため、アップロードを完了できません。</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_INDEX" /> 番目のネットワーク（全 <ph name="NETWORK_COUNT" /> 件）、<ph name="NETWORK_NAME" />、<ph name="CONNECTION_STATUS" />、信号強度 <ph name="SIGNAL_STRENGTH" />%、管理者によって管理、詳細</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_ka.xtb b/ui/chromeos/translations/ui_chromeos_strings_ka.xtb
index 1884930e..0effa56 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_ka.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_ka.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">დაკავშირებულია, ინტერნეტის გარეშე</translation>
 <translation id="8965697826696209160">საკმარისი ადგილი არ არის.</translation>
 <translation id="8970887620466824814">წარმოიქმნა შეფერხება.</translation>
+<translation id="8971742885766657349">მიმდინარეობს სინქრონიზაცია — <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">ჩინური (ტრადიციული) პინ-ინი</translation>
 <translation id="8998871447376656508">თქვენს Google Drive-ზე არ არის საკმარისი თავისუფალი მეხსიერება ატვირთვის შესასრულებლად.</translation>
 <translation id="9003940392834790328">ქსელი <ph name="NETWORK_INDEX" />/<ph name="NETWORK_COUNT" />-დან, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, სიგნალის სიძლიერე: <ph name="SIGNAL_STRENGTH" />%, მართავს თქვენი ადმინისტრატორი, დეტალები</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_pt-BR.xtb b/ui/chromeos/translations/ui_chromeos_strings_pt-BR.xtb
index 0876149..3ebbbf2 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_pt-BR.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_pt-BR.xtb
@@ -1046,6 +1046,7 @@
 <translation id="8949925099261528566">Conectada, sem Internet</translation>
 <translation id="8965697826696209160">Não há espaço suficiente.</translation>
 <translation id="8970887620466824814">Algo deu errado.</translation>
+<translation id="8971742885766657349">Sincronizando (<ph name="PERCENT" />%)</translation>
 <translation id="8997962250644902079">Chinês (tradicional, pinyin)</translation>
 <translation id="8998871447376656508">Não há espaço livre suficiente no seu Google Drive para concluir o upload.</translation>
 <translation id="9003940392834790328">Rede <ph name="NETWORK_INDEX" /> de <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, intensidade do sinal em <ph name="SIGNAL_STRENGTH" />%, gerenciada pelo seu administrador, detalhes</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_pt-PT.xtb b/ui/chromeos/translations/ui_chromeos_strings_pt-PT.xtb
index d320b2d..7c21a395 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_pt-PT.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_pt-PT.xtb
@@ -1046,6 +1046,7 @@
 <translation id="8949925099261528566">Ligação estabelecida, sem Internet</translation>
 <translation id="8965697826696209160">Não existe espaço suficiente.</translation>
 <translation id="8970887620466824814">Ocorreu um erro.</translation>
+<translation id="8971742885766657349">A sincronizar - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Pinyin chinês (tradicional)</translation>
 <translation id="8998871447376656508">Não existe espaço livre suficiente no Google Drive para concluir o carregamento.</translation>
 <translation id="9003940392834790328">Rede <ph name="NETWORK_INDEX" /> de <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, intensidade do sinal: <ph name="SIGNAL_STRENGTH" />%, gerida pelo administrador, detalhes</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_ro.xtb b/ui/chromeos/translations/ui_chromeos_strings_ro.xtb
index 7e20c6d..a8417b8 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_ro.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_ro.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Conectat, fără internet</translation>
 <translation id="8965697826696209160">Nu există spațiu suficient.</translation>
 <translation id="8970887620466824814">A apărut o eroare.</translation>
+<translation id="8971742885766657349">Se sincronizează – <ph name="PERCENT" /> %</translation>
 <translation id="8997962250644902079">Chineză (tradițională) Pinyin</translation>
 <translation id="8998871447376656508">Nu există spațiu liber suficient în Google Drive pentru a finaliza încărcarea.</translation>
 <translation id="9003940392834790328">Rețeaua <ph name="NETWORK_INDEX" /> din <ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, puterea semnalului: <ph name="SIGNAL_STRENGTH" /> %, gestionată de administratorul tău, detalii</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_ru.xtb b/ui/chromeos/translations/ui_chromeos_strings_ru.xtb
index ddf56df..591db6f 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_ru.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_ru.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Подключено, без доступа к интернету</translation>
 <translation id="8965697826696209160">Недостаточно свободного места.</translation>
 <translation id="8970887620466824814">Произошла ошибка</translation>
+<translation id="8971742885766657349">Синхронизация: <ph name="PERCENT" /> %</translation>
 <translation id="8997962250644902079">Китайский (традиционный), пиньинь</translation>
 <translation id="8998871447376656508">Не удалось завершить загрузку. На Google Диске недостаточно свободного места.</translation>
 <translation id="9003940392834790328">Сеть <ph name="NETWORK_INDEX" /> из <ph name="NETWORK_COUNT" />, название – "<ph name="NETWORK_NAME" />", статус подключения – "<ph name="CONNECTION_STATUS" />", уровень сигнала – <ph name="SIGNAL_STRENGTH" /> %, под управлением администратора, подробная информация</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_si.xtb b/ui/chromeos/translations/ui_chromeos_strings_si.xtb
index 51ea82ae..b73b9804 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_si.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_si.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">සම්බන්ධයි, අන්තර්ජාලය නැත</translation>
 <translation id="8965697826696209160">ප්‍රමාණවත් මතකයක් නැත.</translation>
 <translation id="8970887620466824814">යම් දෙයක් වැරදිණි</translation>
+<translation id="8971742885766657349">සමමුහුර්ත කරමින් - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">චීන (සාම්ප්‍රදායික) පින්යින්</translation>
 <translation id="8998871447376656508">උඩුගත කිරීම සම්පූර්ණ කිරීමට ඔබේ Google Drive තුළ ප්‍රමාණවත් නිදහස් ඉඩ නැත.</translation>
 <translation id="9003940392834790328"><ph name="NETWORK_COUNT" />න් <ph name="NETWORK_INDEX" /> වැනි ජාලය, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, සංඥා ප්‍රබලතාව <ph name="SIGNAL_STRENGTH" />%, ඔබේ පරිපාලකයා විසින් කළමනාකරණය කරයි, විස්තර</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_sk.xtb b/ui/chromeos/translations/ui_chromeos_strings_sk.xtb
index 59667b2a..ec0bee6 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_sk.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_sk.xtb
@@ -2,6 +2,7 @@
 <!DOCTYPE translationbundle>
 <translationbundle lang="sk">
 <translation id="1000498691615767391">Vyberte priečinok, ktorý chcete otvoriť</translation>
+<translation id="1014208178561091457">Súbor <ph name="FILE_NAME" /> sa nepodarilo skopírovať, pretože je šifrovaný.</translation>
 <translation id="1047956942837015229">Prebieha odstraňovanie <ph name="COUNT" /> položiek...</translation>
 <translation id="1049926623896334335">Dokument aplikácie Word</translation>
 <translation id="1056775291175587022">Žiadne siete</translation>
@@ -55,6 +56,7 @@
 <translation id="1435838927755162558">Zdieľanie priečinka aplikáciou Parallels Desktop</translation>
 <translation id="1439919885608649279">Osoba s kvetinami</translation>
 <translation id="1458457385801829801">Odpojiť <ph name="TARGET_NAME" /></translation>
+<translation id="146691674290220697">Niekoľko (<ph name="NUMBER_OF_FILES" />) súborov sa nepodarilo skopírovať, pretože sú šifrované.</translation>
 <translation id="1471718551822868769">Slovenská klávesnica</translation>
 <translation id="1482884275703521657">Fínska klávesnica</translation>
 <translation id="148466539719134488">Švajčiarska klávesnica</translation>
@@ -276,6 +278,7 @@
 <translation id="3253225298092156258">Nie je k dispozícii</translation>
 <translation id="3254434849914415189">Zvoľte pre súbory <ph name="FILE_TYPE" /> predvolenú aplikáciu:</translation>
 <translation id="3255159654094949700">Arabská klávesnica</translation>
+<translation id="326396468955264502">Niekoľko (<ph name="NUMBER_OF_FILES" />) súborov sa nepodarilo presunúť, pretože sú šifrované.</translation>
 <translation id="3264582393905923483">Kontext</translation>
 <translation id="3272909651715601089"><ph name="PATH" /> sa nepodarilo otvoriť</translation>
 <translation id="3280431534455935878">Prebieha príprava</translation>
@@ -313,6 +316,7 @@
 <translation id="3523225005467146490">S virtuálnym počítačom <ph name="VM_NAME" /> bol zdieľaný 1 súbor</translation>
 <translation id="3524311639100184459">Upozornenie: Tieto súbory sú dočasné a môžu byť automaticky odstránené na uvoľnenie priestoru na disku.  <ph name="BEGIN_LINK" />Ďalšie informácie<ph name="END_LINK" /></translation>
 <translation id="3527085408025491307">Priečinok</translation>
+<translation id="3529424493985988200">Podrobnosti vám poskytne správca.</translation>
 <translation id="3548125359243647069">Príliš veľakrát bol zadaný nesprávny kód PIN.</translation>
 <translation id="3549797760399244642">Prejsť na adresu drive.google.com...</translation>
 <translation id="3553048479571901246">Ak chcete otvoriť súbory pomocou aplikácie <ph name="APP_NAME" />, najprv ich skopírujte do priečinka so súbormi systému Windows.</translation>
@@ -701,6 +705,7 @@
 <translation id="637062427944097960">Tento súbor je otvorený na inej pracovnej ploche. Ak ho chcete zobraziť, prejdite do profilu <ph name="USER_NAME" /> (<ph name="MAIL_ADDRESS" />).</translation>
 <translation id="6394388407447716302">Iba na čítanie</translation>
 <translation id="6395575651121294044">Počet položiek: <ph name="NUMBER_OF_FILES" /></translation>
+<translation id="6407769893376380348">Súbor <ph name="FILE_NAME" /> sa nepodarilo presunúť, pretože je šifrovaný.</translation>
 <translation id="642282551015776456">Tento názov nie je možné použiť na pomenovanie súboru ani priečinka.</translation>
 <translation id="6423031066725912715">Vietnamská klávesnica s rozložením TCVN</translation>
 <translation id="6430271654280079150">Zostáva vám jeden pokus.</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_zh-CN.xtb b/ui/chromeos/translations/ui_chromeos_strings_zh-CN.xtb
index a4b7158..26e3177e 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_zh-CN.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_zh-CN.xtb
@@ -1036,6 +1036,7 @@
 <translation id="8949925099261528566">已连接，但无法访问互联网</translation>
 <translation id="8965697826696209160">空间不足。</translation>
 <translation id="8970887620466824814">出了点问题。</translation>
+<translation id="8971742885766657349">正在同步 - 已完成 <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">中文（繁体）拼音</translation>
 <translation id="8998871447376656508">您的 Google 云端硬盘中的可用空间不足，无法完成上传。</translation>
 <translation id="9003940392834790328">第 <ph name="NETWORK_INDEX" /> 个网络（共 <ph name="NETWORK_COUNT" /> 个），<ph name="NETWORK_NAME" />，<ph name="CONNECTION_STATUS" />，信号强度为 <ph name="SIGNAL_STRENGTH" />%，由您的管理员管理，详细信息</translation>
diff --git a/ui/chromeos/translations/ui_chromeos_strings_zu.xtb b/ui/chromeos/translations/ui_chromeos_strings_zu.xtb
index 507c98c..150275f 100644
--- a/ui/chromeos/translations/ui_chromeos_strings_zu.xtb
+++ b/ui/chromeos/translations/ui_chromeos_strings_zu.xtb
@@ -1041,6 +1041,7 @@
 <translation id="8949925099261528566">Kuxhunyiwe, ayikho i-inthanethi</translation>
 <translation id="8965697826696209160">Asikho isikhala esanele.</translation>
 <translation id="8970887620466824814">Okuthile akuhambanga kahle.</translation>
+<translation id="8971742885766657349">Iyavumelanisa - <ph name="PERCENT" />%</translation>
 <translation id="8997962250644902079">Chinese (Traditional) Pinyin</translation>
 <translation id="8998871447376656508">Asikho isikhala esanele esikhululekile ku-Google Drive yakho ukuze uqedele ukulayisha.</translation>
 <translation id="9003940392834790328">Inethiwekhi <ph name="NETWORK_INDEX" /> ye-<ph name="NETWORK_COUNT" />, <ph name="NETWORK_NAME" />, <ph name="CONNECTION_STATUS" />, amandla esignali <ph name="SIGNAL_STRENGTH" />%, kuphethwe umlawuli wakho, imininingwane</translation>
diff --git a/ui/gfx/x/atom_cache.cc b/ui/gfx/x/atom_cache.cc
index f7c7a8ea..f1cd9b4 100644
--- a/ui/gfx/x/atom_cache.cc
+++ b/ui/gfx/x/atom_cache.cc
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/check.h"
+#include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "ui/gfx/x/connection.h"
 #include "ui/gfx/x/future.h"
@@ -36,8 +37,12 @@
     "Abs MT Touch Minor",
     "Abs MT Tracking ID",
     "Abs Metrics Type",
+    "Abs Pressure",
+    "Abs Tilt X",
+    "Abs Tilt Y",
+    "Abs X",
+    "Abs Y",
     "CHECK",
-    "CHOME_SELECTION",
     "CHROME_SELECTION",
     "CHROMIUM_COMPOSITE_WINDOW",
     "CHROMIUM_TIMESTAMP",
@@ -213,9 +218,10 @@
   if (auto response =
           connection_->InternAtom(InternAtomRequest{.name = name}).Sync()) {
     atom = response->atom;
-    DUMP_WILL_BE_CHECK_GT(atom, x11::Atom::kLastPredefinedAtom)
+    CHECK_GT(atom, x11::Atom::kLastPredefinedAtom)
         << " Use x11::Atom::" << name << " instead of x11::GetAtom(\"" << name
         << "\")";
+    LOG(ERROR) << "Add " << name << " to kAtomsToCache";
     cached_atoms_.emplace(
         owned_strings_.emplace_back(std::make_unique<std::string>(name))
             ->c_str(),
diff --git a/ui/gfx/x/connection.cc b/ui/gfx/x/connection.cc
index 8bf7e9b..e9034ec7de 100644
--- a/ui/gfx/x/connection.cc
+++ b/ui/gfx/x/connection.cc
@@ -25,6 +25,7 @@
 #include "ui/gfx/x/event.h"
 #include "ui/gfx/x/glx.h"
 #include "ui/gfx/x/keyboard_state.h"
+#include "ui/gfx/x/property_cache.h"
 #include "ui/gfx/x/randr.h"
 #include "ui/gfx/x/render.h"
 #include "ui/gfx/x/screensaver.h"
@@ -85,6 +86,13 @@
   RawError error_bytes_;
 };
 
+Window GetWindowPropertyAsWindow(const GetPropertyResponse& value) {
+  if (const Window* wm_window = PropertyCache::GetAs<Window>(value)) {
+    return *wm_window;
+  }
+  return Window::None;
+}
+
 }  // namespace
 
 // static
@@ -163,6 +171,13 @@
   InitErrorParsers();
 
   atom_cache_ = std::make_unique<AtomCache>(this);
+
+  root_props_ = std::make_unique<PropertyCache>(
+      this, default_root(),
+      std::vector<Atom>{GetAtom("_NET_SUPPORTING_WM_CHECK"),
+                        GetAtom("_NET_SUPPORTED")},
+      base::BindRepeating(&Connection::OnRootPropertyChanged,
+                          base::Unretained(this)));
 }
 
 Connection::~Connection() {
@@ -289,10 +304,35 @@
   return ScopedEventSelector(this, window, event_mask);
 }
 
-Atom Connection::GetAtom(const char* name) {
+Atom Connection::GetAtom(const char* name) const {
   return atom_cache_->GetAtom(name);
 }
 
+std::string Connection::GetWmName() const {
+  if (WmSupportsEwmh()) {
+    size_t size;
+    if (const char* name =
+            wm_props_->GetAs<char>(GetAtom("_NET_WM_NAME"), &size)) {
+      std::string wm_name;
+      wm_name.assign(name, size);
+      return wm_name;
+    }
+  }
+  return std::string();
+}
+
+bool Connection::WmSupportsHint(Atom atom) const {
+  if (WmSupportsEwmh()) {
+    size_t size;
+    if (const Atom* supported =
+            root_props_->GetAs<Atom>(GetAtom("_NET_SUPPORTED"), &size)) {
+      const Atom* end = supported + size;
+      return std::find(supported, end, atom) != end;
+    }
+  }
+  return false;
+}
+
 Connection::Request::Request(ResponseCallback callback)
     : callback(std::move(callback)) {
   DUMP_WILL_BE_CHECK(this->callback);
@@ -851,4 +891,31 @@
   return xcb_generate_id(connection_.get());
 }
 
+void Connection::OnRootPropertyChanged(Atom property,
+                                       const GetPropertyResponse& value) {
+  Atom check_atom = GetAtom("_NET_SUPPORTING_WM_CHECK");
+  if (property == check_atom) {
+    wm_props_.reset();
+    Window wm_window = GetWindowPropertyAsWindow(value);
+    if (wm_window != Window::None) {
+      wm_props_ = std::make_unique<PropertyCache>(
+          this, wm_window,
+          std::vector<Atom>{check_atom, GetAtom("_NET_WM_NAME")});
+    }
+  }
+}
+
+bool Connection::WmSupportsEwmh() const {
+  Atom check_atom = GetAtom("_NET_SUPPORTING_WM_CHECK");
+  Window wm_window = GetWindowPropertyAsWindow(root_props_->Get(check_atom));
+
+  if (!wm_props_) {
+    return false;
+  }
+  if (const x11::Window* wm_check = wm_props_->GetAs<Window>(check_atom)) {
+    return *wm_check == wm_window;
+  }
+  return false;
+}
+
 }  // namespace x11
diff --git a/ui/gfx/x/connection.h b/ui/gfx/x/connection.h
index 905862e..8694dfc 100644
--- a/ui/gfx/x/connection.h
+++ b/ui/gfx/x/connection.h
@@ -29,6 +29,7 @@
 class AtomCache;
 class Event;
 class KeyboardState;
+class PropertyCache;
 class VisualManager;
 class WriteBuffer;
 
@@ -425,7 +426,12 @@
 
   ScopedEventSelector ScopedSelectEvent(Window window, EventMask event_mask);
 
-  Atom GetAtom(const char* name);
+  Atom GetAtom(const char* name) const;
+
+  // Returns an empty string if there is no window manager or the WM is unnamed.
+  std::string GetWmName() const;
+
+  bool WmSupportsHint(Atom atom) const;
 
   // The viz compositor thread hangs a PlatformEventSource off the connection so
   // that it gets destroyed at the appropriate time.
@@ -500,6 +506,10 @@
 
   uint32_t GenerateIdImpl();
 
+  void OnRootPropertyChanged(Atom property, const GetPropertyResponse& value);
+
+  bool WmSupportsEwmh() const;
+
   std::string display_string_;
   int default_screen_id_ = 0;
   std::unique_ptr<xcb_connection_t, void (*)(xcb_connection_t*)> connection_ = {
@@ -555,6 +565,9 @@
   std::unique_ptr<VisualManager> visual_manager_;
 
   std::unique_ptr<AtomCache> atom_cache_;
+
+  std::unique_ptr<PropertyCache> root_props_;
+  std::unique_ptr<PropertyCache> wm_props_;
 };
 
 }  // namespace x11
diff --git a/ui/ozone/platform/x11/test/x11_window_unittest.cc b/ui/ozone/platform/x11/test/x11_window_unittest.cc
index 751d103b..c5cefaa 100644
--- a/ui/ozone/platform/x11/test/x11_window_unittest.cc
+++ b/ui/ozone/platform/x11/test/x11_window_unittest.cc
@@ -324,7 +324,8 @@
     EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 205, 15));
   }
 
-  if (WmSupportsHint(x11::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"))) {
+  if (connection->WmSupportsHint(
+          x11::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"))) {
     // The shape should be changed to a rectangle which fills the entire screen
     // when |widget1| is maximized.
     {
@@ -405,10 +406,10 @@
 // Test that the widget reacts on changes in fullscreen state initiated by the
 // window manager (e.g. via a window manager accelerator key).
 TEST_F(X11WindowTest, MAYBE_WindowManagerTogglesFullscreen) {
-  if (!WmSupportsHint(x11::GetAtom("_NET_WM_STATE_FULLSCREEN")))
-    return;
-
   auto* connection = x11::Connection::Get();
+  if (!connection->WmSupportsHint(x11::GetAtom("_NET_WM_STATE_FULLSCREEN"))) {
+    return;
+  }
 
   TestPlatformWindowDelegate delegate;
   ShapedX11ExtensionDelegate x11_extension_delegate;
diff --git a/ui/ozone/platform/x11/x11_window.cc b/ui/ozone/platform/x11/x11_window.cc
index 86732cb8..f3a0e65 100644
--- a/ui/ozone/platform/x11/x11_window.cc
+++ b/ui/ozone/platform/x11/x11_window.cc
@@ -788,7 +788,7 @@
   // https://code.google.com/p/wmii/issues/detail?id=266
   static bool wm_supports_active_window =
       GuessWindowManager() != WM_WMII &&
-      WmSupportsHint(x11::GetAtom("_NET_ACTIVE_WINDOW"));
+      connection_->WmSupportsHint(x11::GetAtom("_NET_ACTIVE_WINDOW"));
 
   x11::Time timestamp = X11EventSource::GetInstance()->GetTimestamp();
 
@@ -1112,7 +1112,7 @@
       return false;
     }
   }
-  return ui::WmSupportsHint(x11::GetAtom("_GTK_FRAME_EXTENTS"));
+  return connection_->WmSupportsHint(x11::GetAtom("_GTK_FRAME_EXTENTS"));
 }
 
 void X11Window::SetDecorationInsets(const gfx::Insets* insets_px) {
diff --git a/v8 b/v8
index 34503e4..802e4ae 160000
--- a/v8
+++ b/v8
@@ -1 +1 @@
-Subproject commit 34503e45094863db86a81e71dd4e9ebe0011d986
+Subproject commit 802e4aead6e7cf7f12b406e2cdb389334f7d3e3d
