chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/entrypoints/inspector_main/InspectorMain.test.ts

@@ -2,12 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Common from '../../core/common/common.js';
 import * as ProtocolClient from '../../core/protocol_client/protocol_client.js';
 import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 import {
   createTarget,
+  getGetHostConfigStub,
   stubNoopSettings,
 } from '../../testing/EnvironmentHelpers.js';
 import {expectCall} from '../../testing/ExpectStubCall.js';
@@ -15,7 +17,7 @@ import {
   describeWithMockConnection,
   setMockConnectionResponseHandler,
 } from '../../testing/MockConnection.js';
-import type * as UI from '../../ui/legacy/legacy.js';
+import * as UI from '../../ui/legacy/legacy.js';
 
 import * as InspectorMain from './inspector_main.js';
 
@@ -44,167 +46,299 @@ describeWithMockConnection('InspectorMainImpl', () => {
   };
 
   beforeEach(() => {
-    stubNoopSettings();
     sinon.stub(ProtocolClient.InspectorBackend.Connection, 'setFactory');
   });
 
-  it('continues only after primary page target is available', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    let finished = false;
-    inspectorMain.run()
-        .then(() => {
-          finished = true;
-        })
-        .catch(e => {
-          throw e;
-        });
-    await new Promise(resolve => setTimeout(resolve, 0));
-    assert.isFalse(finished);
-    const rootTarget = SDK.TargetManager.TargetManager.instance().rootTarget();
-    SDK.TargetManager.TargetManager.instance().createTarget(
-        'someTargetID' as Protocol.Target.TargetID, 'someName', SDK.Target.Type.FRAME, rootTarget, undefined);
-    await new Promise(resolve => setTimeout(resolve, 0));
-    assert.isTrue(finished);
-  });
+  describe('comparingBrowserSettingWithCookieControlSetting', () => {
+    // Before the tests, we need to add these settings to allow the InspectorMain.run to work
+    beforeEach(async () => {
+      Common.Settings.registerSettingExtension({
+        settingName: 'auto-attach-to-created-pages',
+        settingType: Common.Settings.SettingType.BOOLEAN,
+        defaultValue: false,
+      });
+      Common.Settings.registerSettingExtension({
+        settingName: 'network.ad-blocking-enabled',
+        settingType: Common.Settings.SettingType.BOOLEAN,
+        defaultValue: false,
+      });
+      Common.Settings.registerSettingExtension({
+        settingName: 'emulate-page-focus',
+        settingType: Common.Settings.SettingType.BOOLEAN,
+        defaultValue: false,
+      });
 
-  it('sets main target type to Node if v8only query param present', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    Root.Runtime.Runtime.setQueryParamForTesting('v8only', 'true');
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-    await inspectorMain.run();
+      const storage = Common.Settings.Settings.instance().localStorage;
+      Common.Settings.Settings.instance(
+          {forceNew: true, syncedStorage: storage, globalStorage: storage, localStorage: storage});
+    });
 
-    assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.NODE);
-    Root.Runtime.Runtime.setQueryParamForTesting('v8only', '');
-  });
+    function setBrowserConfig(
+        thirdPartyCookieRestrictionEnabled?: boolean, thirdPartyCookieMetadataEnabled?: boolean,
+        thirdPartyCookieHeuristicsEnabled?: boolean, managedBlockThirdPartyCookies?: boolean|string) {
+      getGetHostConfigStub({
+        thirdPartyCookieControls: {
+          thirdPartyCookieRestrictionEnabled,
+          thirdPartyCookieHeuristicsEnabled,
+          thirdPartyCookieMetadataEnabled,
+          managedBlockThirdPartyCookies,
+        },
+        devToolsPrivacyUI: {enabled: true}
+      });
+    }
 
-  it('sets main target type to Tab if targetType=tab query param present', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-    await runForTabTarget();
+    function setDevtoolsCookieControls(
+        cookieControlOverrideEnabled?: boolean, gracePeriodMitigationEnabled?: boolean,
+        heuristicMitigationEnabled?: boolean) {
+      Common.Settings.Settings.instance().createSetting(
+          'cookie-control-override-enabled', cookieControlOverrideEnabled);
+      Common.Settings.Settings.instance().createSetting(
+          'grace-period-mitigation-disabled', !gracePeriodMitigationEnabled);
+      Common.Settings.Settings.instance().createSetting('heuristic-mitigation-disabled', !heuristicMitigationEnabled);
+    }
 
-    assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.TAB);
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
-  });
+    it('does not show infobar when enterpirse is blocking third-party cookies', async () => {
+      const restrictThirdPartyCookies = true;
+      const gracePeriodEnabled = true;
+      const heuristicsEnabled = true;
+      const enterpriseBlocksThirdPartyCookies = true;
+      setBrowserConfig(
+          restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled, enterpriseBlocksThirdPartyCookies);
+      setDevtoolsCookieControls(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
 
-  it('sets main target type to Frame by default', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-    await inspectorMain.run();
+      const reloadRequiredInfobarSpy =
+          sinon.spy(UI.InspectorView.InspectorView.instance(), 'displayDebuggedTabReloadRequiredWarning');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      await inspectorMain.run();
 
-    assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.FRAME);
-  });
+      assert.isTrue(reloadRequiredInfobarSpy.notCalled);
+    });
 
-  it('creates main target waiting for debugger if the main target is frame and panel is sources', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    Root.Runtime.Runtime.setQueryParamForTesting('panel', 'sources');
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-
-    const waitForDebugger = sinon.spy();
-    const debuggerPause = sinon.spy();
-    setMockConnectionResponseHandler('Page.waitForDebugger', waitForDebugger);
-    setMockConnectionResponseHandler('Debugger.enable', () => ({debuggerId: DEBUGGER_ID}));
-    setMockConnectionResponseHandler('Debugger.pause', debuggerPause);
-    await inspectorMain.run();
-    assert.isTrue(waitForDebugger.calledOnce);
-    assert.isTrue(debuggerPause.calledOnce);
-
-    Root.Runtime.Runtime.setQueryParamForTesting('panel', '');
-  });
+    it('does not show infobar when control setting is undefined', async () => {
+      const restrictThirdPartyCookies = true;
+      const gracePeriodEnabled = true;
+      const heuristicsEnabled = true;
+      setBrowserConfig(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
 
-  it('wait for Debugger.enable before calling Debugger.pause', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    Root.Runtime.Runtime.setQueryParamForTesting('panel', 'sources');
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-
-    const debuggerPause = sinon.stub();
-    setMockConnectionResponseHandler('Debugger.pause', debuggerPause);
-    const debuggerPauseCalled = expectCall(debuggerPause);
-
-    let debuggerEnable = (_: Protocol.Debugger.EnableResponse) => {};
-    setMockConnectionResponseHandler('Debugger.enable', () => new Promise<Protocol.Debugger.EnableResponse>(resolve => {
-                                                          debuggerEnable = resolve;
-                                                        }));
-
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
-    const result = inspectorMain.run();
-    assert.isFalse(debuggerPause.called);
-    debuggerEnable({debuggerId: DEBUGGER_ID, getError: () => undefined});
-    await Promise.all([debuggerPauseCalled, result]);
-    assert.isTrue(debuggerPause.calledOnce);
-    Root.Runtime.Runtime.setQueryParamForTesting('panel', '');
-  });
+      const reloadRequiredInfobarSpy =
+          sinon.spy(UI.InspectorView.InspectorView.instance(), 'displayDebuggedTabReloadRequiredWarning');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      await inspectorMain.run();
 
-  it('frontend correctly registers if Debugger.enable fails', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+      assert.isTrue(reloadRequiredInfobarSpy.notCalled);
+    });
 
-    setMockConnectionResponseHandler('Debugger.enable', () => ({getError: () => 'Debugger.enable failed'}));
-    await inspectorMain.run();
+    it('does not show infobar when control settings match browser settings', async () => {
+      const restrictThirdPartyCookies = true;
+      const gracePeriodEnabled = true;
+      const heuristicsEnabled = true;
+      setBrowserConfig(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
+      setDevtoolsCookieControls(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
 
-    const target = SDK.TargetManager.TargetManager.instance().rootTarget();
-    assert.isNotNull(target);
-    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel;
-    assert.isFalse(debuggerModel.debuggerEnabled());
-  });
+      const reloadRequiredInfobarSpy =
+          sinon.spy(UI.InspectorView.InspectorView.instance(), 'displayDebuggedTabReloadRequiredWarning');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      await inspectorMain.run();
 
-  it('calls Runtime.runIfWaitingForDebugger for Node target', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('v8only', 'true');
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    await inspectorMain.run();
-    assert.isTrue(runIfWaitingForDebugger.calledOnce);
-    Root.Runtime.Runtime.setQueryParamForTesting('v8only', '');
-  });
+      assert.isTrue(reloadRequiredInfobarSpy.notCalled);
+    });
 
-  it('calls Runtime.runIfWaitingForDebugger for frame target', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    await inspectorMain.run();
-    assert.isTrue(runIfWaitingForDebugger.calledOnce);
-  });
+    it('shows infobar when cookie control override differs from browser setting', async () => {
+      const restrictThirdPartyCookies = true;
+      const gracePeriodEnabled = true;
+      const heuristicsEnabled = true;
+      setBrowserConfig(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
+      setDevtoolsCookieControls(!restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
 
-  it('does not call Runtime.runIfWaitingForDebugger for Tab target', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    await runForTabTarget();
-    assert.isFalse(runIfWaitingForDebugger.called);
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
-  });
+      const reloadRequiredInfobarSpy =
+          sinon.spy(UI.InspectorView.InspectorView.instance(), 'displayDebuggedTabReloadRequiredWarning');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      await inspectorMain.run();
 
-  it('sets frame target to "main"', async () => {
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    await inspectorMain.run();
-    assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.name(), 'Main');
-  });
+      assert.isTrue(reloadRequiredInfobarSpy.calledOnce);
+    });
 
-  it('sets tab target to "tab"', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    await runForTabTarget();
-    assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.name(), 'Tab');
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+    it('shows infobar when a mitigation override differs from browser setting', async () => {
+      const restrictThirdPartyCookies = true;
+      const gracePeriodEnabled = true;
+      const heuristicsEnabled = true;
+      setBrowserConfig(restrictThirdPartyCookies, gracePeriodEnabled, heuristicsEnabled);
+      setDevtoolsCookieControls(restrictThirdPartyCookies, !gracePeriodEnabled, heuristicsEnabled);
+
+      const reloadRequiredInfobarSpy =
+          sinon.spy(UI.InspectorView.InspectorView.instance(), 'displayDebuggedTabReloadRequiredWarning');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      await inspectorMain.run();
+
+      assert.isTrue(reloadRequiredInfobarSpy.calledOnce);
+    });
   });
 
-  it('sets main frame target to "main"', async () => {
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
-    const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
-    const runIfWaitingForDebugger = sinon.spy();
-    setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
-    const runPromise = inspectorMain.run();
-    const prerenderTarget = createTarget(
-        {parentTarget: SDK.TargetManager.TargetManager.instance().rootTarget() || undefined, subtype: 'prerender'});
-    const mainFrameTarget =
-        createTarget({parentTarget: SDK.TargetManager.TargetManager.instance().rootTarget() || undefined});
-    await runPromise;
-    assert.notStrictEqual(prerenderTarget.name(), 'Main');
-    assert.strictEqual(mainFrameTarget.name(), 'Main');
-    Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+  describe('withNoopSettings', () => {
+    beforeEach(() => {
+      stubNoopSettings();
+      getGetHostConfigStub({devToolsPrivacyUI: {enabled: false}});
+    });
+
+    it('continues only after primary page target is available', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      let finished = false;
+      inspectorMain.run()
+          .then(() => {
+            finished = true;
+          })
+          .catch(e => {
+            throw e;
+          });
+      await new Promise(resolve => setTimeout(resolve, 0));
+      assert.isFalse(finished);
+      const rootTarget = SDK.TargetManager.TargetManager.instance().rootTarget();
+      SDK.TargetManager.TargetManager.instance().createTarget(
+          'someTargetID' as Protocol.Target.TargetID, 'someName', SDK.Target.Type.FRAME, rootTarget, undefined);
+      await new Promise(resolve => setTimeout(resolve, 0));
+      assert.isTrue(finished);
+    });
+
+    it('sets main target type to Node if v8only query param present', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      Root.Runtime.Runtime.setQueryParamForTesting('v8only', 'true');
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+      await inspectorMain.run();
+
+      assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.NODE);
+      Root.Runtime.Runtime.setQueryParamForTesting('v8only', '');
+    });
+
+    it('sets main target type to Tab if targetType=tab query param present', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+      await runForTabTarget();
+
+      assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.TAB);
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+    });
+
+    it('sets main target type to Frame by default', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+      await inspectorMain.run();
+
+      assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.type(), SDK.Target.Type.FRAME);
+    });
+
+    it('creates main target waiting for debugger if the main target is frame and panel is sources', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      Root.Runtime.Runtime.setQueryParamForTesting('panel', 'sources');
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+
+      const waitForDebugger = sinon.spy();
+      const debuggerPause = sinon.spy();
+      setMockConnectionResponseHandler('Page.waitForDebugger', waitForDebugger);
+      setMockConnectionResponseHandler('Debugger.enable', () => ({debuggerId: DEBUGGER_ID}));
+      setMockConnectionResponseHandler('Debugger.pause', debuggerPause);
+      await inspectorMain.run();
+      assert.isTrue(waitForDebugger.calledOnce);
+      assert.isTrue(debuggerPause.calledOnce);
+
+      Root.Runtime.Runtime.setQueryParamForTesting('panel', '');
+    });
+
+    it('wait for Debugger.enable before calling Debugger.pause', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      Root.Runtime.Runtime.setQueryParamForTesting('panel', 'sources');
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+
+      const debuggerPause = sinon.stub();
+      setMockConnectionResponseHandler('Debugger.pause', debuggerPause);
+      const debuggerPauseCalled = expectCall(debuggerPause);
+
+      let debuggerEnable = (_: Protocol.Debugger.EnableResponse) => {};
+      setMockConnectionResponseHandler(
+          'Debugger.enable', () => new Promise<Protocol.Debugger.EnableResponse>(resolve => {
+                               debuggerEnable = resolve;
+                             }));
+
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+      const result = inspectorMain.run();
+      assert.isFalse(debuggerPause.called);
+      debuggerEnable({debuggerId: DEBUGGER_ID, getError: () => undefined});
+      await Promise.all([debuggerPauseCalled, result]);
+      assert.isTrue(debuggerPause.calledOnce);
+      Root.Runtime.Runtime.setQueryParamForTesting('panel', '');
+    });
+
+    it('frontend correctly registers if Debugger.enable fails', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      assert.notExists(SDK.TargetManager.TargetManager.instance().rootTarget());
+
+      setMockConnectionResponseHandler('Debugger.enable', () => ({getError: () => 'Debugger.enable failed'}));
+      await inspectorMain.run();
+
+      const target = SDK.TargetManager.TargetManager.instance().rootTarget();
+      assert.isNotNull(target);
+      const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel;
+      assert.isFalse(debuggerModel.debuggerEnabled());
+    });
+
+    it('calls Runtime.runIfWaitingForDebugger for Node target', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('v8only', 'true');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      await inspectorMain.run();
+      assert.isTrue(runIfWaitingForDebugger.calledOnce);
+      Root.Runtime.Runtime.setQueryParamForTesting('v8only', '');
+    });
+
+    it('calls Runtime.runIfWaitingForDebugger for frame target', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      await inspectorMain.run();
+      assert.isTrue(runIfWaitingForDebugger.calledOnce);
+    });
+
+    it('does not call Runtime.runIfWaitingForDebugger for Tab target', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      await runForTabTarget();
+      assert.isFalse(runIfWaitingForDebugger.called);
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+    });
+
+    it('sets frame target to "main"', async () => {
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      await inspectorMain.run();
+      assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.name(), 'Main');
+    });
+
+    it('sets tab target to "tab"', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      await runForTabTarget();
+      assert.strictEqual(SDK.TargetManager.TargetManager.instance().rootTarget()?.name(), 'Tab');
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+    });
+
+    it('sets main frame target to "main"', async () => {
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', 'tab');
+      const inspectorMain = InspectorMain.InspectorMain.InspectorMainImpl.instance({forceNew: true});
+      const runIfWaitingForDebugger = sinon.spy();
+      setMockConnectionResponseHandler('Runtime.runIfWaitingForDebugger', runIfWaitingForDebugger);
+      const runPromise = inspectorMain.run();
+      const prerenderTarget = createTarget(
+          {parentTarget: SDK.TargetManager.TargetManager.instance().rootTarget() || undefined, subtype: 'prerender'});
+      const mainFrameTarget =
+          createTarget({parentTarget: SDK.TargetManager.TargetManager.instance().rootTarget() || undefined});
+      await runPromise;
+      assert.notStrictEqual(prerenderTarget.name(), 'Main');
+      assert.strictEqual(mainFrameTarget.name(), 'Main');
+      Root.Runtime.Runtime.setQueryParamForTesting('targetType', '');
+    });
   });
 });

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -9,6 +9,7 @@ import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 import * as MobileThrottling from '../../panels/mobile_throttling/mobile_throttling.js';
+import * as Security from '../../panels/security/security.js';
 import * as Components from '../../ui/legacy/components/utils/utils.js';
 import * as UI from '../../ui/legacy/legacy.js';
 
@@ -106,7 +107,7 @@ export class InspectorMainImpl implements Common.Runnable.Runnable {
       if (type !== SDK.Target.Type.TAB) {
         void target.runtimeAgent().invoke_runIfWaitingForDebugger();
       }
-    }, Components.TargetDetachedDialog.TargetDetachedDialog.webSocketConnectionLost);
+    }, Components.TargetDetachedDialog.TargetDetachedDialog.connectionLost);
 
     new SourcesPanelIndicator();
     new BackendSettingsSync();
@@ -116,6 +117,44 @@ export class InspectorMainImpl implements Common.Runnable.Runnable {
         Host.InspectorFrontendHostAPI.Events.ReloadInspectedPage, ({data: hard}) => {
           SDK.ResourceTreeModel.ResourceTreeModel.reloadAllPages(hard);
         });
+
+    // Skip possibly showing the cookie control reload banner if devtools UI is not enabled or if there is an enterprise policy blocking third party cookies
+    if (!Common.Settings.Settings.instance().getHostConfig().devToolsPrivacyUI?.enabled ||
+        Common.Settings.Settings.instance().getHostConfig().thirdPartyCookieControls?.managedBlockThirdPartyCookies ===
+            true) {
+      return;
+    }
+
+    // Third party cookie control settings according to the browser
+    const browserCookieControls = Common.Settings.Settings.instance().getHostConfig().thirdPartyCookieControls;
+
+    // Devtools cookie controls settings
+    const cookieControlOverrideSetting =
+        Common.Settings.Settings.instance().createSetting('cookie-control-override-enabled', undefined);
+    const gracePeriodMitigationDisabledSetting =
+        Common.Settings.Settings.instance().createSetting('grace-period-mitigation-disabled', undefined);
+    const heuristicMitigationDisabledSetting =
+        Common.Settings.Settings.instance().createSetting('heuristic-mitigation-disabled', undefined);
+
+    // If there are saved cookie control settings, check to see if they differ from the browser config. If they do, prompt a page reload so the user will see the cookie controls behavior.
+    if (cookieControlOverrideSetting.get() !== undefined) {
+      if (browserCookieControls?.thirdPartyCookieRestrictionEnabled !== cookieControlOverrideSetting.get()) {
+        Security.CookieControlsView.showInfobar();
+        return;
+      }
+
+      // If the devtools third-party cookie control is active, we also need to check if there's a discrepancy in the mitigation behavior.
+      if (cookieControlOverrideSetting.get()) {
+        if (browserCookieControls?.thirdPartyCookieMetadataEnabled === gracePeriodMitigationDisabledSetting.get()) {
+          Security.CookieControlsView.showInfobar();
+          return;
+        }
+        if (browserCookieControls?.thirdPartyCookieHeuristicsEnabled === heuristicMitigationDisabledSetting.get()) {
+          Security.CookieControlsView.showInfobar();
+          return;
+        }
+      }
+    }
   }
 }
 
@@ -153,7 +192,7 @@ export class NodeIndicator implements UI.Toolbar.Provider {
   readonly #button: UI.Toolbar.ToolbarItem;
   private constructor() {
     const element = document.createElement('div');
-    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: [nodeIconStyles]});
+    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: nodeIconStyles});
     this.#element = shadowRoot.createChild('div', 'node-icon');
     element.addEventListener(
         'click', () => Host.InspectorFrontendHost.InspectorFrontendHostInstance.openNodeFrontend(), false);

package/front_end/entrypoints/inspector_main/OutermostTargetSelector.ts

@@ -151,7 +151,7 @@ export class OutermostTargetSelector implements SDK.TargetManager.Observer, UI.S
   createElementForItem(item: SDK.Target.Target): Element {
     const element = document.createElement('div');
     element.classList.add('target');
-    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: [outermostTargetSelectorStyles]});
+    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: outermostTargetSelectorStyles});
     const title = shadowRoot.createChild('div', 'title');
     UI.UIUtils.createTextChild(title, Platform.StringUtilities.trimEndWithMaxLength(this.titleFor(item), 100));
     const subTitle = shadowRoot.createChild('div', 'subtitle');

package/front_end/entrypoints/inspector_main/RenderingOptions.ts

@@ -206,6 +206,7 @@ const supportsPrefersContrast = (): boolean => {
 export class RenderingOptionsView extends UI.Widget.VBox {
   constructor() {
     super(true);
+    this.registerRequiredCSS(renderingOptionsStyles);
 
     this.element.setAttribute('jslog', `${VisualLogging.panel('rendering').track({resize: true})}`);
 
@@ -304,10 +305,6 @@ export class RenderingOptionsView extends UI.Widget.VBox {
       this.contentElement.appendChild(control);
     }
   }
-  override wasShown(): void {
-    super.wasShown();
-    this.registerCSSFiles([renderingOptionsStyles]);
-  }
 }
 
 export class ReloadActionDelegate implements UI.ActionRegistration.ActionDelegate {

package/front_end/entrypoints/js_app/js_app.ts

@@ -5,6 +5,7 @@
 import '../shell/shell.js';
 import '../../panels/js_timeline/js_timeline-meta.js';
 import '../../panels/mobile_throttling/mobile_throttling-meta.js';
+import '../../panels/network/network-meta.js';
 
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
@@ -59,7 +60,7 @@ export class JsMainImpl implements Common.Runnable.Runnable {
       const target = SDK.TargetManager.TargetManager.instance().createTarget(
           'main', i18nString(UIStrings.main), SDK.Target.Type.NODE, null);
       void target.runtimeAgent().invoke_runIfWaitingForDebugger();
-    }, Components.TargetDetachedDialog.TargetDetachedDialog.webSocketConnectionLost);
+    }, Components.TargetDetachedDialog.TargetDetachedDialog.connectionLost);
   }
 }
 

package/front_end/entrypoints/main/ExecutionContextSelector.ts

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as SDK from '../../core/sdk/sdk.js';
 import type * as Common from '../../core/common/common.js';
+import * as SDK from '../../core/sdk/sdk.js';
 import type * as UI from '../../ui/legacy/legacy.js';
 
 export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObserver<SDK.RuntimeModel.RuntimeModel> {