Attachment #388830 for bug #206110

View Details Raw Unified Return to Bug 206110

| Differences between



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * inspector/protocol/Runtime.json:
        Introduce an `ExecutionContextType` enum instead of `isPageContext` so the frontend can
        decide whether/how to show a picker for that execution context.

2020-01-26  Alexey Shvayka  <shvaikalesh@gmail.com>

        Invalid ranges in character classes should be banned in unicode patterns



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        Test: inspector/runtime/executionContextCreated-isolated-world.html

        * bindings/js/DOMWrapperWorld.h:
        (WebCore::DOMWrapperWorld::create):
        (WebCore::DOMWrapperWorld::type const): Added.
        (WebCore::DOMWrapperWorld::isNormal const):
        (WebCore::DOMWrapperWorld::name const): Added.
        * bindings/js/DOMWrapperWorld.cpp:
        (WebCore::DOMWrapperWorld::DOMWrapperWorld):
        * bindings/js/ScriptController.h:
        * bindings/js/ScriptController.cpp:
        (WebCore::ScriptController::createWorld):
        * bindings/js/WebCoreJSClientData.cpp:
        (WebCore::JSVMClientData::initNormalWorld):
        Require that a name is specified when creating an isolated world (except the normal world)
        so that Web Inspector has something to show in the execution context picker.

        * inspector/InspectorInstrumentation.cpp:
        (WebCore::InspectorInstrumentation::didClearWindowObjectInWorldImpl):
        * inspector/agents/InspectorPageAgent.h:
        * inspector/agents/InspectorPageAgent.cpp:
        (WebCore::InspectorPageAgent::didClearWindowObjectInWorld):
        * inspector/agents/page/PageDebuggerAgent.h:
        * inspector/agents/page/PageDebuggerAgent.cpp:
        (WebCore::PageDebuggerAgent::didClearWindowObjectInWorld):
        * inspector/agents/page/PageRuntimeAgent.h:
        * inspector/agents/page/PageRuntimeAgent.cpp:
        (WebCore::PageRuntimeAgent::didClearWindowObjectInWorld):
        (WebCore::PageRuntimeAgent::reportExecutionContextCreation):
        (WebCore::toProtocol): Added.
        (WebCore::PageRuntimeAgent::notifyContextCreated):
        Allow this instrumentation call to pass through to the agents for non-`Normal` worlds.

        * html/HTMLMediaElement.cpp:
        (WebCore::HTMLMediaElement::ensureIsolatedWorld):
        * html/HTMLPlugInImageElement.cpp:
        (WebCore::plugInImageElementIsolatedWorld):
        * Modules/plugins/QuickTimePluginReplacement.mm:
        (WebCore::QuickTimePluginReplacement::isolatedWorld):
        Mark these worlds as `Internal`.

        * testing/Internals.idl:
        * testing/Internals.h:
        * testing/Internals.cpp:
        (WebCore::Internals::evaluateInWorldIgnoringException): Added.

2020-01-26  youenn fablet  <youenn@apple.com>

        Use ObjectIdentifier for remote RealtimeMediaSource



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * UserInterface/Models/ExecutionContext.js:
        (WI.ExecutionContext):
        (WI.ExecutionContext.typeFromPayload): Added.
        (WI.ExecutionContext.prototype.get type): Added.
        (WI.ExecutionContext.prototype.get isPageContext): Deleted.

        * UserInterface/Models/ExecutionContextList.js:
        (WI.ExecutionContextList.prototype.add):
        * UserInterface/Models/Frame.js:
        (WI.Frame.prototype.addExecutionContext):
        * UserInterface/Controllers/NetworkManager.js:
        (WI.NetworkManager.prototype.executionContextCreated):
        The `Normal` execution context (of which there should only be one) is considered the "page"
        execution context.

        * UserInterface/Protocol/DirectBackendTarget.js:
        (WI.DirectBackendTarget):
        * UserInterface/Protocol/PageTarget.js:
        (WI.PageTarget):
        * UserInterface/Protocol/WorkerTarget.js:
        (WI.WorkerTarget):
        Default to a `Normal` execution context.

        * UserInterface/Views/QuickConsole.js:
        (WI.QuickConsole):
        (WI.QuickConsole.prototype._displayNameForExecutionContext): Added.
        (WI.QuickConsole.prototype._resolveDesiredActiveExecutionContext): Added.
        (WI.QuickConsole.prototype._setActiveExecutionContext): Added.
        (WI.QuickConsole.prototype._updateActiveExecutionContextDisplay): Added.
        (WI.QuickConsole.prototype._populateActiveExecutionContextNavigationItemContextMenu): Added.
        (WI.QuickConsole.prototype._handleConsoleSavedResultAliasSettingChanged): Added.
        (WI.QuickConsole.prototype._handleEngineeringShowInternalExecutionContextsSettingChanged): Added.
        (WI.QuickConsole.prototype._handleFramePageExecutionContextChanged): Added.
        (WI.QuickConsole.prototype._handleFrameExecutionContextsCleared): Added.
        (WI.QuickConsole.prototype._handleDebuggerActiveCallFrameDidChange): Added.
        (WI.QuickConsole.prototype._handleActiveExecutionContextChanged): Added.
        (WI.QuickConsole.prototype._handleTransitionPageTarget): Added.
        (WI.QuickConsole.prototype._handleTargetRemoved): Added.
        (WI.QuickConsole.prototype._handleInspectedNodeChanged): Added.
        (WI.QuickConsole.prototype._updateStyles):
        (WI.QuickConsole.prototype.get navigationBar): Deleted.
        (WI.QuickConsole.prototype._pageTargetTransitioned): Deleted.
        (WI.QuickConsole.prototype._initializeMainExecutionContextPathComponent): Deleted.
        (WI.QuickConsole.prototype.layout): Deleted.
        (WI.QuickConsole.prototype._preferredNameForFrame): Deleted.
        (WI.QuickConsole.prototype._selectExecutionContext): Deleted.
        (WI.QuickConsole.prototype._updateAutomaticExecutionContextPathComponentTooltip): Deleted.
        (WI.QuickConsole.prototype._executionContextPathComponentsToDisplay): Deleted.
        (WI.QuickConsole.prototype._rebuildExecutionContextPathComponents): Deleted.
        (WI.QuickConsole.prototype._framePageExecutionContextsChanged): Deleted.
        (WI.QuickConsole.prototype._frameExecutionContextsCleared): Deleted.
        (WI.QuickConsole.prototype._activeExecutionContextChanged): Deleted.
        (WI.QuickConsole.prototype._createExecutionContextPathComponent): Deleted.
        (WI.QuickConsole.prototype._compareExecutionContextPathComponents): Deleted.
        (WI.QuickConsole.prototype._insertOtherExecutionContextPathComponent): Deleted.
        (WI.QuickConsole.prototype._removeOtherExecutionContextPathComponent): Deleted.
        (WI.QuickConsole.prototype._insertExecutionContextPathComponentForFrame): Deleted.
        (WI.QuickConsole.prototype._removeExecutionContextPathComponentForFrame): Deleted.
        (WI.QuickConsole.prototype._targetAdded): Deleted.
        (WI.QuickConsole.prototype._targetRemoved): Deleted.
        (WI.QuickConsole.prototype._pathComponentSelected): Deleted.
        (WI.QuickConsole.prototype._pathComponentClicked): Deleted.
        (WI.QuickConsole.prototype._debuggerActiveCallFrameDidChange): Deleted.
        * UserInterface/Views/QuickConsole.css:
        (.quick-console > .console-prompt):
        (.quick-console > .navigation-bar):
        (.quick-console > .navigation-bar .active-execution-context): Added.
        (.quick-console > .navigation-bar .active-execution-context > .selector-arrows): Added.
        (.quick-console > .navigation-bar .active-execution-context:not(.automatic)): Added.
        (.quick-console > .navigation-bar .active-execution-context:not(.automatic) > .selector-arrows): Added.
        (.quick-console .execution-context): Deleted.
        (.quick-console > .navigation-bar > .hierarchical-path .execution-context): Deleted.
        (.quick-console > .navigation-bar > .hierarchical-path .execution-context .separator): Deleted.
        (.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context)): Deleted.
        (.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context): Deleted.
        (.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context .selector-arrows): Deleted.
        Replace the `WI.HierarchicalPathNavigationItem` with a plain `WI.NavigationItem` that shows
        a `WI.ContextMenu` with all valid execution contexts organized as follows:

            Auto - <display name for execution context of inspected DOM node>
            ----------
            Main Frame Normal Execution Context
                All User Exection Contexts for the Main Frame
                All Internal Exection Contexts for the Main Frame (with the engineering setting)
            Frames
                Frame Normal Execution Context
                    All User Exection Contexts for the Frame
                    All Internal Exection Contexts for the Frame (with the engineering setting)
                ...
            Workers
                Worker Execution Context
                ...

        Everything is checkmark selectable other than the separator, "Frames", and "Workers".

        * UserInterface/Controllers/RuntimeManager.js:
        (WI.RuntimeManager):
        (WI.RuntimeManager.prototype._frameExecutionContextsCleared): Deleted.
        Let the UI (`WI.QuickConsole`) decide when to automatically update the active execution
        context when a frame is removed that owned the active execution context.

        * UserInterface/Controllers/TargetManager.js:
        (WI.TargetManager.prototype.get workerTargets): Added.
        (WI.TargetManager.prototype._terminatePageTarget):
        Convenience function for getting the list of worker targets.

        * UserInterface/Views/GroupNavigationItem.js:
        (WI.GroupNavigationItem.prototype.update):
        (WI.GroupNavigationItem.prototype.didAttach):
        Update the items whenever the group updates.

        * UserInterface/Main.html:
        * UserInterface/Views/SizesToFitNavigationBar.js: Renamed from Source/WebInspectorUI/UserInterface/Views/QuickConsoleNavigationBar.js.
        (WI.SizesToFitNavigationBar):
        (WI.SizesToFitNavigationBar.prototype.get sizesToFit):
        Rename to allow for other use cases.

        * UserInterface/Views/ContextMenu.js:
        (WI.ContextSubMenuItem.prototype.appendHeader): Added.
        Convenience method for creating a disabled item.

        * UserInterface/Base/Setting.js:
        * UserInterface/Views/SettingsTabContentView.js:
        (WI.SettingsTabContentView.prototype._createEngineeringSettingsView):
        Create an engineering setting that controls whether `Internal` execution contexts are shown.

        * UserInterface/Test/InspectorProtocol.js:
        (InspectorProtocol.addEventListener):
        (InspectorProtocol.removeEventListener): Added.

        * Localizations/en.lproj/localizedStrings.js:

2020-01-21  Keith Rollin  <krollin@apple.com>

        Fix tvOS values in SUPPORTED_PLATFORMS



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * WebProcess/InjectedBundle/InjectedBundleScriptWorld.h:
        * WebProcess/InjectedBundle/InjectedBundleScriptWorld.cpp:
        (WebKit::InjectedBundleScriptWorld::create):

        * WebProcess/UserContent/WebUserContentController.cpp:
        (WebKit::WebUserContentController::addUserContentWorlds):
        * WebProcess/InjectedBundle/API/glib/WebKitScriptWorld.cpp:
        (webkit_script_world_new):
        (webkit_script_world_new_with_name):
        Treat isolated worlds created by API calls as `User` worlds.

2020-01-26  Chris Dumez  <cdumez@apple.com>

        Frequent sync BackForwardBackListCount/BackForwardForwardListCount IPC on reddit.com



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * WebView/WebScriptWorld.mm:
        (-[WebScriptWorld init]):
        Treat isolated worlds created by API calls as `User` worlds.

2020-01-26  Said Abou-Hallawa  <said@apple.com>

        Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * WebScriptWorld.cpp:
        (WebScriptWorld::createInstance):
        Treat isolated worlds created by API calls as `User` worlds.

2020-01-26  Said Abou-Hallawa  <said@apple.com>

        Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler



            "type": "integer",
            "description": "Id of an execution context."
        },
        {
            "id": "ExecutionContextType",
            "type": "string",
            "enum": ["normal", "user", "internal"],
            "description": "Type of the execution context."
        },
        {
            "id": "ExecutionContextDescription",
            "type": "object",
            "description": "Description of an isolated world.",
            "properties": [
                { "name": "id", "$ref": "ExecutionContextId", "description": "Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed." },
                { "name": "type", "$ref": "ExecutionContextType" },
                { "name": "name", "type": "string", "description": "Human readable name describing given context."},
                { "name": "frameId", "$ref": "Network.FrameId", "description": "Id of the owning frame." }
            ]

Lines 137-143 RenderPtr<RenderElement> QuickTimePluginReplacement::createElementRenderer(HTMLP a/Source/WebCore/Modules/plugins/QuickTimePluginReplacement.mm_sec1
- a/Source/WebCore/Modules/plugins/QuickTimePluginReplacement.mm -1 / +1 lines
137		137
138	DOMWrapperWorld& QuickTimePluginReplacement::isolatedWorld()	138	DOMWrapperWorld& QuickTimePluginReplacement::isolatedWorld()
139	{	139	{
140	static DOMWrapperWorld& isolatedWorld = DOMWrapperWorld::create(commonVM()).leakRef();	140	static DOMWrapperWorld& isolatedWorld = DOMWrapperWorld::create(commonVM(), DOMWrapperWorld::Type::Internal, "QuickTimePluginReplacement"_s).leakRef();
141	return isolatedWorld;	141	return isolatedWorld;
142	}	142	}
143		143

Lines 31-40 a/Source/WebCore/bindings/js/DOMWrapperWorld.cpp_sec1
- a/Source/WebCore/bindings/js/DOMWrapperWorld.cpp -2 / +5 lines
31	namespace WebCore {	31	namespace WebCore {
32	using namespace JSC;	32	using namespace JSC;
33		33
34	DOMWrapperWorld::DOMWrapperWorld(JSC::VM& vm, bool isNormal)	34	DOMWrapperWorld::DOMWrapperWorld(JSC::VM& vm, Type type, const String& name)
35	: m_vm(vm)	35	: m_vm(vm)
36	, m_isNormal(isNormal)	36	, m_name(name)
		37	, m_type(type)
37	{	38	{
		39	ASSERT(!name.isEmpty() \|\| m_type == Type::Normal);
		40
38	VM::ClientData* clientData = m_vm.clientData;	41	VM::ClientData* clientData = m_vm.clientData;
39	ASSERT(clientData);	42	ASSERT(clientData);
40	static_cast<JSVMClientData>(clientData)->rememberWorld(this);	43	static_cast<JSVMClientData>(clientData)->rememberWorld(this);

Lines 32-40 typedef HashMap<void*, JSC::Weak<JSC::JSObject>> DOMObjectWrapperMap; a/Source/WebCore/bindings/js/DOMWrapperWorld.h_sec1
- a/Source/WebCore/bindings/js/DOMWrapperWorld.h -5 / +16 lines
32		32
33	class DOMWrapperWorld : public RefCounted<DOMWrapperWorld> {	33	class DOMWrapperWorld : public RefCounted<DOMWrapperWorld> {
34	public:	34	public:
35	static Ref<DOMWrapperWorld> create(JSC::VM& vm, bool isNormal = false)	35	enum class Type {
		36	Normal, // Main (e.g. Page)
		37	User, // User Scripts (e.g. Extensions)
		38	Internal, // WebKit Internal (e.g. Media Controls)
		39	};
		40
		41	static Ref<DOMWrapperWorld> create(JSC::VM& vm, Type type = Type::Internal, const String& name = { })
36	{	42	{
37	return adoptRef(*new DOMWrapperWorld(vm, isNormal));	43	return adoptRef(*new DOMWrapperWorld(vm, type, name));
38	}	44	}
39	WEBCORE_EXPORT ~DOMWrapperWorld();	45	WEBCORE_EXPORT ~DOMWrapperWorld();
40		46
Lines 52-70 public: a/Source/WebCore/bindings/js/DOMWrapperWorld.h_sec2
52		58
53	DOMObjectWrapperMap& wrappers() { return m_wrappers; }	59	DOMObjectWrapperMap& wrappers() { return m_wrappers; }
54		60
55	bool isNormal() const { return m_isNormal; }	61	Type type() const { return m_type; }
		62	bool isNormal() const { return m_type == Type::Normal; }
		63
		64	const String& name() const { return m_name; }
56		65
57	JSC::VM& vm() const { return m_vm; }	66	JSC::VM& vm() const { return m_vm; }
58		67
59	protected:	68	protected:
60	DOMWrapperWorld(JSC::VM&, bool isNormal);	69	DOMWrapperWorld(JSC::VM&, Type, const String& name);
61		70
62	private:	71	private:
63	JSC::VM& m_vm;	72	JSC::VM& m_vm;
64	HashSet<WindowProxy*> m_jsWindowProxies;	73	HashSet<WindowProxy*> m_jsWindowProxies;
65	DOMObjectWrapperMap m_wrappers;	74	DOMObjectWrapperMap m_wrappers;
66		75
67	bool m_isNormal;	76	String m_name;
		77	Type m_type { Type::Internal };
		78
68	bool m_shadowRootIsAlwaysOpen { false };	79	bool m_shadowRootIsAlwaysOpen { false };
69	bool m_shouldDisableOverrideBuiltinsBehavior { false };	80	bool m_shouldDisableOverrideBuiltinsBehavior { false };
70	};	81	};



#include "CommonVM.h"
#include "ContentSecurityPolicy.h"
#include "CustomHeaderFields.h"
#include "DOMWrapperWorld.h"
#include "DocumentLoader.h"
#include "Event.h"
#include "Frame.h"

    return evaluateModule(sourceURL, moduleRecord, mainThreadNormalWorld());
}

Ref<DOMWrapperWorld> ScriptController::createWorld(const String& name, WorldType type)
{
    return DOMWrapperWorld::create(commonVM(), type == WorldType::User ? DOMWrapperWorld::Type::User : DOMWrapperWorld::Type::Internal, name);
}

void ScriptController::getAllWorlds(Vector<Ref<DOMWrapperWorld>>& worlds)



    explicit ScriptController(Frame&);
    ~ScriptController();

    enum class WorldType { User, Internal };
    WEBCORE_EXPORT static Ref<DOMWrapperWorld> createWorld(const String& name, WorldType = WorldType::Internal);

    JSDOMWindow* globalObject(DOMWrapperWorld& world)
    {

    WEBCORE_EXPORT ValueOrException executeUserAgentScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture);
    WEBCORE_EXPORT void executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld&, RunJavaScriptParameters&&, ResolveFunction&&);
    JSC::JSValue evaluateIgnoringException(const ScriptSourceCode&);
    WEBCORE_EXPORT JSC::JSValue evaluateInWorldIgnoringException(const ScriptSourceCode&, DOMWrapperWorld&);

    Expected<void, ExceptionDetails> shouldAllowUserAgentScripts(Document&) const;




{
    JSVMClientData* clientData = new JSVMClientData(*vm);
    vm->clientData = clientData; // ~VM deletes this pointer.

    vm->heap.addMarkingConstraint(makeUnique<DOMGCOutputConstraint>(*vm, *clientData));

    clientData->m_normalWorld = DOMWrapperWorld::create(*vm, DOMWrapperWorld::Type::Normal);
    vm->m_typedArrayController = adoptRef(new WebCoreTypedArrayController());
}


Lines 7218-7224 RefPtr<VideoPlaybackQuality> HTMLMediaElement::getVideoPlaybackQuality() a/Source/WebCore/html/HTMLMediaElement.cpp_sec1
- a/Source/WebCore/html/HTMLMediaElement.cpp -1 / +1 lines
7218	DOMWrapperWorld& HTMLMediaElement::ensureIsolatedWorld()	7218	DOMWrapperWorld& HTMLMediaElement::ensureIsolatedWorld()
7219	{	7219	{
7220	if (!m_isolatedWorld)	7220	if (!m_isolatedWorld)
7221	m_isolatedWorld = DOMWrapperWorld::create(commonVM());	7221	m_isolatedWorld = DOMWrapperWorld::create(commonVM(), DOMWrapperWorld::Type::Internal, makeString("Media Controls (", localName(), ')'));
7222	return *m_isolatedWorld;	7222	return *m_isolatedWorld;
7223	}	7223	}
7224		7224

Lines 363-369 void HTMLPlugInImageElement::updateSnapshot(Image* image) a/Source/WebCore/html/HTMLPlugInImageElement.cpp_sec1
- a/Source/WebCore/html/HTMLPlugInImageElement.cpp -1 / +1 lines
363		363
364	static DOMWrapperWorld& plugInImageElementIsolatedWorld()	364	static DOMWrapperWorld& plugInImageElementIsolatedWorld()
365	{	365	{
366	static auto& isolatedWorld = DOMWrapperWorld::create(commonVM()).leakRef();	366	static auto& isolatedWorld = DOMWrapperWorld::create(commonVM(), DOMWrapperWorld::Type::Internal, "Plugin"_s).leakRef();
367	return isolatedWorld;	367	return isolatedWorld;
368	}	368	}
369		369




void InspectorInstrumentation::didClearWindowObjectInWorldImpl(InstrumentingAgents& instrumentingAgents, Frame& frame, DOMWrapperWorld& world)
{
    if (&world != &mainThreadNormalWorld())
        return;

    if (auto* pageDebuggerAgent = instrumentingAgents.pageDebuggerAgent())
        pageDebuggerAgent->didClearWindowObjectInWorld(frame, world);

    if (auto* pageRuntimeAgent = instrumentingAgents.pageRuntimeAgent())
        pageRuntimeAgent->didClearWindowObjectInWorld(frame, world);

    if (auto* pageAgent = instrumentingAgents.inspectorPageAgent())
        pageAgent->didClearWindowObjectInWorld(frame, world);
}

bool InspectorInstrumentation::isDebuggerPausedImpl(InstrumentingAgents& instrumentingAgents)

Lines 37-42 a/Source/WebCore/inspector/agents/InspectorPageAgent.cpp_sec1
- a/Source/WebCore/inspector/agents/InspectorPageAgent.cpp -1 / +5 lines
37	#include "Cookie.h"	37	#include "Cookie.h"
38	#include "CookieJar.h"	38	#include "CookieJar.h"
39	#include "CustomHeaderFields.h"	39	#include "CustomHeaderFields.h"
		40	#include "DOMWrapperWorld.h"
40	#include "Document.h"	41	#include "Document.h"
41	#include "DocumentLoader.h"	42	#include "DocumentLoader.h"
42	#include "Frame.h"	43	#include "Frame.h"
Lines 770-777 void InspectorPageAgent::defaultAppearanceDidChange(bool useDarkAppearance) a/Source/WebCore/inspector/agents/InspectorPageAgent.cpp_sec2
770	m_frontendDispatcher->defaultAppearanceDidChange(useDarkAppearance ? Inspector::Protocol::Page::Appearance::Dark : Inspector::Protocol::Page::Appearance::Light);	771	m_frontendDispatcher->defaultAppearanceDidChange(useDarkAppearance ? Inspector::Protocol::Page::Appearance::Dark : Inspector::Protocol::Page::Appearance::Light);
771	}	772	}
772		773
773	void InspectorPageAgent::didClearWindowObjectInWorld(Frame& frame)	774	void InspectorPageAgent::didClearWindowObjectInWorld(Frame& frame, DOMWrapperWorld& world)
774	{	775	{
		776	if (&world != &mainThreadNormalWorld())
		777	return;
		778
775	if (m_bootstrapScript.isEmpty())	779	if (m_bootstrapScript.isEmpty())
776	return;	780	return;
777		781




namespace WebCore {

class DOMWrapperWorld;
class DocumentLoader;
class Frame;
class InspectorClient;

    void defaultAppearanceDidChange(bool useDarkAppearance);
    void applyUserAgentOverride(String&);
    void applyEmulatedMedia(String&);
    void didClearWindowObjectInWorld(Frame&, DOMWrapperWorld&);
    void didPaint(RenderObject&, const LayoutRect&);
    void didLayout();
    void didScroll();



#include "PageDebuggerAgent.h"

#include "CachedResource.h"
#include "DOMWrapperWorld.h"
#include "Document.h"
#include "Frame.h"
#include "InspectorPageAgent.h"

    return injectedScript;
}

void PageDebuggerAgent::didClearWindowObjectInWorld(Frame& frame, DOMWrapperWorld& world)
{
    if (!frame.isMainFrame() || &world != &mainThreadNormalWorld())
        return;

    didClearGlobalObject();




namespace WebCore {

class DOMWrapperWorld;
class Document;
class Frame;
class Page;

    void breakpointActionLog(JSC::JSGlobalObject*, const String&) override;

    // InspectorInstrumentation
    void didClearWindowObjectInWorld(Frame&, DOMWrapperWorld&);
    void mainFrameStartedLoading();
    void mainFrameStoppedLoading();
    void mainFrameNavigated();



#include "config.h"
#include "PageRuntimeAgent.h"

#include "DOMWrapperWorld.h"
#include "Document.h"
#include "Frame.h"
#include "InspectorPageAgent.h"

#include <JavaScriptCore/InjectedScript.h>
#include <JavaScriptCore/InjectedScriptManager.h>

using Inspector::Protocol::Runtime::ExecutionContextDescription;

namespace WebCore {

using namespace Inspector;

    mainWorldExecState(&frame);
}

void PageRuntimeAgent::didClearWindowObjectInWorld(Frame& frame, DOMWrapperWorld& world)
{
    auto* pageAgent = m_instrumentingAgents.inspectorPageAgent();
    if (!pageAgent)
        return;

    notifyContextCreated(pageAgent->frameId(&frame), frame.script().globalObject(world), world);
    auto* scriptState = mainWorldExecState(&frame);
    notifyContextCreated(frameId, scriptState, nullptr, true);
}

InjectedScript PageRuntimeAgent::injectedScriptForEval(ErrorString& errorString, const int* executionContextId)

    if (!pageAgent)
        return;

    for (auto* frame = &m_inspectedPage.mainFrame(); frame; frame = frame->tree().traverseNext()) {
    for (Frame* frame = &m_inspectedPage.mainFrame(); frame; frame = frame->tree().traverseNext()) {
        if (!frame->script().canExecuteScripts(NotAboutToExecuteScript))
            continue;

        auto frameId = pageAgent->frameId(frame);

        // Always send the main world first.
        auto* mainGlobalObject = mainWorldExecState(frame);
        notifyContextCreated(frameId, mainGlobalObject, mainThreadNormalWorld());

        for (auto& jsWindowProxy : frame->windowProxy().jsWindowProxiesAsVector()) {
            auto* globalObject = jsWindowProxy->window();
            if (globalObject == mainGlobalObject)
                continue;

            auto& securityOrigin = downcast<DOMWindow>(jsWindowProxy->wrapped()).document()->securityOrigin();
            notifyContextCreated(frameId, globalObject, jsWindowProxy->world(), &securityOrigin);
        }
        isolatedContexts.clear();
    }
}

static Inspector::Protocol::Runtime::ExecutionContextType toProtocol(DOMWrapperWorld::Type type)
{
    switch (type) {
    case DOMWrapperWorld::Type::Normal:
        return Inspector::Protocol::Runtime::ExecutionContextType::Normal;
    case DOMWrapperWorld::Type::User:
        return Inspector::Protocol::Runtime::ExecutionContextType::User;
    case DOMWrapperWorld::Type::Internal:
        return Inspector::Protocol::Runtime::ExecutionContextType::Internal;
    }

    ASSERT_NOT_REACHED();
    return Inspector::Protocol::Runtime::ExecutionContextType::Internal;
}

void PageRuntimeAgent::notifyContextCreated(const String& frameId, JSC::JSGlobalObject* globalObject, const DOMWrapperWorld& world, SecurityOrigin* securityOrigin)
{
    auto injectedScript = injectedScriptManager().injectedScriptFor(globalObject);
    if (injectedScript.hasNoValue())
        return;

    auto name = world.name();
    if (name.isEmpty() && securityOrigin)
        name = securityOrigin->toRawString();

    m_frontendDispatcher->executionContextCreated(Inspector::Protocol::Runtime::ExecutionContextDescription::create()
        .setId(injectedScriptManager().injectedScriptIdFor(globalObject))
        .setType(toProtocol(world.type()))
        .setName(name)
        .setFrameId(frameId)
        .release());




namespace WebCore {

class DOMWrapperWorld;
class Frame;
class Page;
class SecurityOrigin;


    // InspectorInstrumentation
    void frameNavigated(Frame&);
    void didClearWindowObjectInWorld(Frame&, DOMWrapperWorld&);

private:
    Inspector::InjectedScript injectedScriptForEval(ErrorString&, const int* executionContextId) override;
    void muteConsole() override;
    void unmuteConsole() override;
    void reportExecutionContextCreation();
    void notifyContextCreated(const String& frameId, JSC::JSGlobalObject*, const DOMWrapperWorld&, SecurityOrigin* = nullptr);

    std::unique_ptr<Inspector::RuntimeFrontendDispatcher> m_frontendDispatcher;
    RefPtr<Inspector::RuntimeBackendDispatcher> m_backendDispatcher;

Lines 162-167 a/Source/WebCore/testing/Internals.cpp_sec1
- a/Source/WebCore/testing/Internals.cpp +9 lines
162	#include "SVGPathStringBuilder.h"	162	#include "SVGPathStringBuilder.h"
163	#include "SVGSVGElement.h"	163	#include "SVGSVGElement.h"
164	#include "SWClientConnection.h"	164	#include "SWClientConnection.h"
		165	#include "ScriptController.h"
165	#include "ScriptedAnimationController.h"	166	#include "ScriptedAnimationController.h"
166	#include "ScrollingCoordinator.h"	167	#include "ScrollingCoordinator.h"
167	#include "ScrollingMomentumCalculator.h"	168	#include "ScrollingMomentumCalculator.h"
Lines 3487-3492 bool Internals::isFromCurrentWorld(JSC::JSValue value) const a/Source/WebCore/testing/Internals.cpp_sec2
3487	return isWorldCompatible(*vm.topCallFrame->lexicalGlobalObject(vm), value);	3488	return isWorldCompatible(*vm.topCallFrame->lexicalGlobalObject(vm), value);
3488	}	3489	}
3489		3490
		3491	JSC::JSValue Internals::evaluateInWorldIgnoringException(const String& name, const String& source)
		3492	{
		3493	auto* document = contextDocument();
		3494	auto& scriptController = document->frame()->script();
		3495	auto world = ScriptController::createWorld(name);
		3496	return scriptController.evaluateInWorldIgnoringException(ScriptSourceCode(source), world);
		3497	}
		3498
3490	void Internals::setUsesOverlayScrollbars(bool enabled)	3499	void Internals::setUsesOverlayScrollbars(bool enabled)
3491	{	3500	{
3492	WebCore::DeprecatedGlobalSettings::setUsesOverlayScrollbars(enabled);	3501	WebCore::DeprecatedGlobalSettings::setUsesOverlayScrollbars(enabled);

Lines 516-521 public: a/Source/WebCore/testing/Internals.h_sec1
- a/Source/WebCore/testing/Internals.h +1 lines
516	Ref<SerializedScriptValue> deserializeBuffer(ArrayBuffer&) const;	516	Ref<SerializedScriptValue> deserializeBuffer(ArrayBuffer&) const;
517		517
518	bool isFromCurrentWorld(JSC::JSValue) const;	518	bool isFromCurrentWorld(JSC::JSValue) const;
		519	JSC::JSValue evaluateInWorldIgnoringException(const String& name, const String& source);
519		520
520	void setUsesOverlayScrollbars(bool);	521	void setUsesOverlayScrollbars(bool);
521	void setUsesMockScrollAnimator(bool);	522	void setUsesMockScrollAnimator(bool);

Lines 548-553 enum CompositingPolicy { a/Source/WebCore/testing/Internals.idl_sec1
- a/Source/WebCore/testing/Internals.idl +1 lines
548	ArrayBuffer serializeObject(SerializedScriptValue object);	548	ArrayBuffer serializeObject(SerializedScriptValue object);
549		549
550	boolean isFromCurrentWorld(any obj);	550	boolean isFromCurrentWorld(any obj);
		551	any evaluateInWorldIgnoringException(DOMString name, DOMString source);
551		552
552	void setUsesOverlayScrollbars(boolean enabled);	553	void setUsesOverlayScrollbars(boolean enabled);
553	void setUsesMockScrollAnimator(boolean enabled);	554	void setUsesMockScrollAnimator(boolean enabled);



localizedStrings["Audit version: %s"] = "Audit version: %s";
localizedStrings["Audits"] = "Audits";
localizedStrings["Author Style Sheet"] = "Author Style Sheet";
localizedStrings["Auto"] = "Auto";
localizedStrings["Auto - %s"] = "Auto - %s";
localizedStrings["Auto Increment"] = "Auto Increment";
localizedStrings["Auto \u2014 %s"] = "Auto \u2014 %s";
localizedStrings["Auto-expand"] = "Auto-expand";
localizedStrings["Automatically continue after evaluating"] = "Automatically continue after evaluating";
localizedStrings["Available Style Sheets"] = "Available Style Sheets";

localizedStrings["Worker"] = "Worker";
localizedStrings["Worker Thread"] = "Worker Thread";
localizedStrings["Worker Threads"] = "Worker Threads";
localizedStrings["Worker \u2014 %s"] = "Worker \u2014 %s";
localizedStrings["Worker: %s"] = "Worker: %s";
localizedStrings["Workers"] = "Workers";
localizedStrings["Wrap lines to editor width"] = "Wrap lines to editor width";
localizedStrings["XBM"] = "XBM";
localizedStrings["XHR"] = "XHR";

Lines 227-232 WI.settings = { a/Source/WebInspectorUI/UserInterface/Base/Setting.js_sec1
- a/Source/WebInspectorUI/UserInterface/Base/Setting.js +1 lines
227	protocolFilterMultiplexingBackendMessages: new WI.Setting("protocol-filter-multiplexing-backend-messages", true),	227	protocolFilterMultiplexingBackendMessages: new WI.Setting("protocol-filter-multiplexing-backend-messages", true),
228		228
229	// Engineering	229	// Engineering
		230	engineeringShowInternalExecutionContexts: new WI.EngineeringSetting("engineering-show-internal-execution-contexts", false),
230	engineeringShowInternalScripts: new WI.EngineeringSetting("engineering-show-internal-scripts", false),	231	engineeringShowInternalScripts: new WI.EngineeringSetting("engineering-show-internal-scripts", false),
231	engineeringPauseForInternalScripts: new WI.EngineeringSetting("engineering-pause-for-internal-scripts", false),	232	engineeringPauseForInternalScripts: new WI.EngineeringSetting("engineering-pause-for-internal-scripts", false),
232	engineeringShowInternalObjectsInHeapSnapshot: new WI.EngineeringSetting("engineering-show-internal-objects-in-heap-snapshot", false),	233	engineeringShowInternalObjectsInHeapSnapshot: new WI.EngineeringSetting("engineering-show-internal-objects-in-heap-snapshot", false),

Lines 1646-1652 function isWebKitInternalScript(url) a/Source/WebInspectorUI/UserInterface/Base/Utilities.js_sec1
- a/Source/WebInspectorUI/UserInterface/Base/Utilities.js -1 / +1 lines
1646		1646
1647	function isWebKitExtensionScheme(scheme)	1647	function isWebKitExtensionScheme(scheme)
1648	{	1648	{
1649	return scheme && scheme.endsWith("extension");	1649	return scheme && scheme.endsWith("-extension");
1650	}	1650	}
1651		1651
1652	function isFunctionStringNativeCode(str)	1652	function isFunctionStringNativeCode(str)




    // RuntimeObserver

    executionContextCreated(payload)
    {
        let frame = this.frameForIdentifier(payload.frameId);
        console.assert(frame);
        if (!frame)
            return;

        let type = WI.ExecutionContext.typeFromPayload(payload);
        let target = frame.mainResource.target;
        let executionContext = new WI.ExecutionContext(target, payload.id, type, payload.name, frame);
        frame.addExecutionContext(executionContext);
    }




                    target.RuntimeAgent.setSavedResultAlias(WI.settings.consoleSavedResultAlias.value);
            }
        });

        WI.Frame.addEventListener(WI.Frame.Event.ExecutionContextsCleared, this._frameExecutionContextsCleared, this);
    }

    // Static


    // Private

    _frameExecutionContextsCleared(event)
    {
        let contexts = event.data.contexts || [];

        let currentContextWasDestroyed = contexts.some((context) => context.id === this._activeExecutionContext.id);
        if (currentContextWasDestroyed)
            this.activeExecutionContext = WI.mainTarget.executionContext;
    }

    _tryApplyAwaitConvenience(originalExpression)
    {
        let esprimaSyntaxTree;

Lines 44-49 WI.TargetManager = class TargetManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/TargetManager.js_sec1
- a/Source/WebInspectorUI/UserInterface/Controllers/TargetManager.js -2 / +6 lines
44	return this._cachedTargetsList;	44	return this._cachedTargetsList;
45	}	45	}
46		46
		47	get workerTargets()
		48	{
		49	return this.targets.filter((target) => target.type === WI.TargetType.Worker);
		50	}
		51
47	get allTargets()	52	get allTargets()
48	{	53	{
49	return Array.from(this._targets.values());	54	return Array.from(this._targets.values());
Lines 275-282 WI.TargetManager = class TargetManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/TargetManager.js_sec2
275	console.assert(WI.sharedApp.debuggableType === WI.DebuggableType.WebPage);	280	console.assert(WI.sharedApp.debuggableType === WI.DebuggableType.WebPage);
276		281
277	// Remove any Worker targets associated with this page.	282	// Remove any Worker targets associated with this page.
278	let workerTargets = WI.targets.filter((x) => x.type === WI.TargetType.Worker);	283	for (let workerTarget of this.workerTargets)
279	for (let workerTarget of workerTargets)
280	WI.workerManager.workerTerminated(workerTarget.identifier);	284	WI.workerManager.workerTerminated(workerTarget.identifier);
281		285
282	WI.pageTarget = null;	286	WI.pageTarget = null;



    <script src="Views/ProfileView.js"></script>
    <script src="Views/ProgressView.js"></script>
    <script src="Views/QuickConsole.js"></script>
    <script src="Views/QuickConsoleNavigationBar.js"></script>
    <script src="Views/RadioButtonNavigationItem.js"></script>
    <script src="Views/RangeChart.js"></script>
    <script src="Views/RecordingActionTreeElement.js"></script>

    <script src="Views/ShaderProgramContentView.js"></script>
    <script src="Views/ShaderProgramTreeElement.js"></script>
    <script src="Views/Sidebar.js"></script>
    <script src="Views/SizesToFitNavigationBar.js"></script>
    <script src="Views/Slider.js"></script>
    <script src="Views/SoftContextMenu.js"></script>
    <script src="Views/SourceCodeTextEditor.js"></script>




WI.ExecutionContext = class ExecutionContext
{
    constructor(target, id, type, name, frame)
    {
        console.assert(target instanceof WI.Target);
        console.assert(typeof id === "number" || id === WI.RuntimeManager.TopLevelExecutionContextIdentifier);
        console.assert(Object.values(WI.ExecutionContext.Type).includes(type));
        console.assert(!name || typeof name === "string");
        console.assert(frame instanceof WI.Frame || id === WI.RuntimeManager.TopLevelExecutionContextIdentifier);

        this._target = target;
        this._id = id;
        this._type = type || WI.ExecutionContext.Type.Internal;
        this._name = name || "";
        this._frame = frame || null;
    }

    // Static

    static typeFromPayload(payload)
    {
        // COMPATIBILITY (iOS 13.1): `Runtime.ExecutionContextType` did not exist yet.
        if (!("type" in payload))
            return payload.isPageContext ? WI.ExecutionContext.Type.Normal : WI.ExecutionContext.Type.Internal;

        switch (payload.type) {
        case InspectorBackend.Enum.Runtime.ExecutionContextType.Normal:
            return WI.ExecutionContext.Type.Normal;
        case InspectorBackend.Enum.Runtime.ExecutionContextType.User:
            return WI.ExecutionContext.Type.User;
        case InspectorBackend.Enum.Runtime.ExecutionContextType.Internal:
            return WI.ExecutionContext.Type.Internal;
        }

        console.assert(false, "Unknown Runtime.ExecutionContextType", payload.type);
        return WI.ExecutionContext.Type.Internal;
    }

    // Public

    get target() { return this._target; }
    get id() { return this._id; }
    get type() { return this._type; }
    get name() { return this._name; }
    get isPageContext() { return this._isPageContext; }
    get frame() { return this._frame; }
};

WI.ExecutionContext.Type = {
    Normal: "normal",
    User: "user",
    Internal: "internal",
};



    {
        // COMPATIBILITY (iOS 13.0): Older iOS releases will send duplicates.
        // Newer releases will not and this check should be removed eventually.
        if (context.type === WI.ExecutionContext.Type.Normal && this._pageExecutionContext) {
            console.assert(context.id === this._pageExecutionContext.id);
            return;
        }

        this._contexts.push(context);

        if (context.type === WI.ExecutionContext.Type.Normal && context.target.type === WI.TargetType.Page) {
            console.assert(!this._pageExecutionContext);
            this._pageExecutionContext = context;
            return true;
        }

        return false;
    }

    clear()

Lines 223-231 WI.Frame = class Frame extends WI.Object a/Source/WebInspectorUI/UserInterface/Models/Frame.js_sec1
- a/Source/WebInspectorUI/UserInterface/Models/Frame.js -2 / +5 lines
223		223
224	addExecutionContext(context)	224	addExecutionContext(context)
225	{	225	{
226	var changedPageContext = this._executionContextList.add(context);	226	this._executionContextList.add(context);
227		227
228	if (changedPageContext)	228	this.dispatchEventToListeners(WI.Frame.Event.ExecutionContextAdded, {context});
		229
		230	if (this._executionContextList.pageExecutionContext === context)
229	this.dispatchEventToListeners(WI.Frame.Event.PageExecutionContextChanged);	231	this.dispatchEventToListeners(WI.Frame.Event.PageExecutionContextChanged);
230	}	232	}
231		233
Lines 509-514 WI.Frame.Event = { a/Source/WebInspectorUI/UserInterface/Models/Frame.js_sec2
509	ChildFrameWasRemoved: "frame-child-frame-was-removed",	511	ChildFrameWasRemoved: "frame-child-frame-was-removed",
510	AllChildFramesRemoved: "frame-all-child-frames-removed",	512	AllChildFramesRemoved: "frame-all-child-frames-removed",
511	PageExecutionContextChanged: "frame-page-execution-context-changed",	513	PageExecutionContextChanged: "frame-page-execution-context-changed",
		514	ExecutionContextAdded: "frame-execution-context-added",
512	ExecutionContextsCleared: "frame-execution-contexts-cleared"	515	ExecutionContextsCleared: "frame-execution-contexts-cleared"
513	};	516	};
514		517

Lines 35-41 WI.DirectBackendTarget = class DirectBackendTarget extends WI.Target a/Source/WebInspectorUI/UserInterface/Protocol/DirectBackendTarget.js_sec1
- a/Source/WebInspectorUI/UserInterface/Protocol/DirectBackendTarget.js -1 / +1 lines
35	let {type, displayName} = DirectBackendTarget.connectionInfoForDebuggable();	35	let {type, displayName} = DirectBackendTarget.connectionInfoForDebuggable();
36	super(parentTarget, targetId, displayName, type, InspectorBackend.backendConnection);	36	super(parentTarget, targetId, displayName, type, InspectorBackend.backendConnection);
37		37
38	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, displayName, true, null);	38	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, WI.ExecutionContext.Type.Normal, displayName);
39	this._mainResource = null;	39	this._mainResource = null;
40	}	40	}
41		41

Lines 29-35 WI.PageTarget = class PageTarget extends WI.Target a/Source/WebInspectorUI/UserInterface/Protocol/PageTarget.js_sec1
- a/Source/WebInspectorUI/UserInterface/Protocol/PageTarget.js -2 / +1 lines
29	{	29	{
30	super(parentTarget, targetId, name, WI.TargetType.Page, connection, options);	30	super(parentTarget, targetId, name, WI.TargetType.Page, connection, options);
31		31
32	const isPageContext = true;	32	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, WI.ExecutionContext.Type.Normal, this.displayName);
33	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, this.displayName, isPageContext, null);
34	}	33	}
35	};	34	};



    {
        super(parentTarget, workerId, name, WI.TargetType.Worker, connection, options);

        this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, WI.ExecutionContext.Type.Normal, this.displayName);
        this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, this.displayName, isPageContext, null);
    }

    // Protected (Target)



        throw new Error("Cannot register the same listener more than once.");

    listeners.push(listener);
    return listener;
};

InspectorProtocol.removeEventListener = function(eventTypeOrObject, listener)
{
    let event = eventTypeOrObject;
    if (typeof eventTypeOrObject === "object")
        ({event, listener} = eventTypeOrObject);

    if (typeof event !== "string")
        throw new Error("Event name must be a string.");

    if (typeof listener !== "function")
        throw new Error("Event listener must be callable.");

    // Convert to an array of listeners.
    let listeners = InspectorProtocol.eventHandler[event];
    if (!listeners)
        return;

    listeners.removeAll(listener);
};

InspectorProtocol.checkForError = function(responseObject)

Lines 116-121 WI.ContextSubMenuItem = class ContextSubMenuItem extends WI.ContextMenuItem a/Source/WebInspectorUI/UserInterface/Views/ContextMenu.js_sec1
- a/Source/WebInspectorUI/UserInterface/Views/ContextMenu.js +7 lines
116	return item;	116	return item;
117	}	117	}
118		118
		119	appendHeader(label)
		120	{
		121	return this.appendItem(label, () => {
		122	console.assert(false, "not reached");
		123	}, true);
		124	}
		125
119	appendSeparator()	126	appendSeparator()
120	{	127	{
121	if (this._items.length)	128	if (this._items.length)

Lines 71-76 WI.GroupNavigationItem = class GroupNavigationItem extends WI.NavigationItem a/Source/WebInspectorUI/UserInterface/Views/GroupNavigationItem.js_sec1
- a/Source/WebInspectorUI/UserInterface/Views/GroupNavigationItem.js +4 lines
71	{	71	{
72	super.update(options);	72	super.update(options);
73		73
		74	this._updateItems();
		75
74	for (let item of this._navigationItems)	76	for (let item of this._navigationItems)
75	item.update(options);	77	item.update(options);
76	}	78	}
Lines 79-84 WI.GroupNavigationItem = class GroupNavigationItem extends WI.NavigationItem a/Source/WebInspectorUI/UserInterface/Views/GroupNavigationItem.js_sec2
79	{	81	{
80	super.didAttach(navigationBar);	82	super.didAttach(navigationBar);
81		83
		84	this._updateItems();
		85
82	for (let item of this._navigationItems)	86	for (let item of this._navigationItems)
83	item.didAttach(navigationBar);	87	item.didAttach(navigationBar);
84	}	88	}




    align-items: flex-start;

    max-height: 33vh;

    overflow-y: auto;
    overflow-x: hidden;

}

.quick-console > .navigation-bar {
    background: transparent;
    border: none;

    height: 21px;
    border-bottom: none;
}

.quick-console > .navigation-bar .active-execution-context {
    margin-top: -1px;
}

.quick-console > .navigation-bar > .hierarchical-path .execution-context {
    -webkit-margin-end: 7px;
}

.quick-console > .navigation-bar > .hierarchical-path .execution-context .separator {
    display: none;
}

.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) {
    -webkit-padding-start: 5px;
    -webkit-padding-end: 1px;
    font-family: -webkit-system-font, sans-serif;
    font-size: 11px;
}

.quick-console > .navigation-bar .active-execution-context > .selector-arrows {
    width: 5px;
    height: 16px;
    margin-top: 2px;
    margin-bottom: 2px;
    -webkit-margin-start: 4px;
    -webkit-margin-end: 3px;
    opacity: 0.6;
}

.quick-console > .navigation-bar .active-execution-context:not(.automatic) {
    margin-top: -1px;
    height: 20px;
    -webkit-margin-start: 5px;
    line-height: 20px;
    color: var(--selected-foreground-color);
    background-color: var(--selected-background-color);
    border-radius: 3px;
}

.quick-console > .navigation-bar .active-execution-context:not(.automatic) > .selector-arrows {
    color: var(--selected-foreground-color);
    opacity: 1;
}



        this._toggleOrFocusKeyboardShortcut.implicitlyPreventsDefault = false;
        this._keyboardShortcutDisabled = false;

        this._useExecutionContextOfInspectedNode = InspectorBackend.hasDomain("DOM");
        this._restoreSelectedExecutionContextForFrame = null;

        this._mainExecutionContextPathComponent = null;
        this._otherExecutionContextPathComponents = [];

        this._frameToPathComponent = new Map;
        this._targetToPathComponent = new Map;

        this._shouldAutomaticallySelectExecutionContext = true;
        this._restoreSelectedExecutionContextForFrame = false;

        this.element.classList.add("quick-console");
        this.element.addEventListener("mousedown", this._handleMouseDown.bind(this));

        // would be for CodeMirror's event handler to pass if it doesn't do anything.
        this.prompt.escapeKeyHandlerWhenEmpty = function() { WI.toggleSplitConsole(); };

        this._navigationBar = new WI.SizesToFitNavigationBar;
        this.addSubview(this._navigationBar);

        this._activeExecutionContextNavigationItemDivider = new WI.DividerNavigationItem;
        this._navigationBar.addNavigationItem(this._activeExecutionContextNavigationItemDivider);
        this._navigationBar.addNavigationItem(this._executionContextSelectorItem);

        this._activeExecutionContextNavigationItem = new WI.NavigationItem("active-execution-context");
        WI.addMouseDownContextMenuHandlers(this._activeExecutionContextNavigationItem.element, this._populateActiveExecutionContextNavigationItemContextMenu.bind(this));
        this._navigationBar.addNavigationItem(this._activeExecutionContextNavigationItem);

        this._updateActiveExecutionContextDisplay();

        WI.settings.consoleSavedResultAlias.addEventListener(WI.Setting.Event.Changed, this._handleConsoleSavedResultAliasSettingChanged, this);
        WI.settings.engineeringShowInternalExecutionContexts.addEventListener(WI.Setting.Event.Changed, this._handleEngineeringShowInternalExecutionContextsSettingChanged, this);

        WI.Frame.addEventListener(WI.Frame.Event.PageExecutionContextChanged, this._handleFramePageExecutionContextChanged, this);
        WI.Frame.addEventListener(WI.Frame.Event.ExecutionContextsCleared, this._handleFrameExecutionContextsCleared, this);

        WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.ActiveCallFrameDidChange, this._handleDebuggerActiveCallFrameDidChange, this);

        WI.runtimeManager.addEventListener(WI.RuntimeManager.Event.ActiveExecutionContextChanged, this._handleActiveExecutionContextChanged, this);
        WI.notifications.addEventListener(WI.Notification.TransitionPageTarget, this._pageTargetTransitioned, this);

        WI.notifications.addEventListener(WI.Notification.TransitionPageTarget, this._handleTransitionPageTarget, this);

        WI.targetManager.addEventListener(WI.TargetManager.Event.TargetRemoved, this._handleTargetRemoved, this);

        WI.domManager.addEventListener(WI.DOMManager.Event.InspectedNodeChanged, this._handleInspectedNodeChanged, this);

        WI.consoleDrawer.toggleButtonShortcutTooltip(this._toggleOrFocusKeyboardShortcut);
        WI.consoleDrawer.addEventListener(WI.ConsoleDrawer.Event.CollapsedStateChanged, this._updateStyles, this);
        WI.TabBrowser.addEventListener(WI.TabBrowser.Event.SelectedTabContentViewDidChange, this._updateStyles, this);

        WI.whenTargetsAvailable().then(() => {
            this._updateActiveExecutionContextDisplay();
        });
    }

    // Public

    get navigationBar()
    {
        return this._navigationBar;
    }

    set keyboardShortcutDisabled(disabled)
    {
        this._keyboardShortcutDisabled = disabled;

        super.closed();
    }

    _pageTargetTransitioned()
    {
        this._initializeMainExecutionContextPathComponent();
    }

    _initializeMainExecutionContextPathComponent()
    {
        if (!WI.mainTarget || WI.mainTarget instanceof WI.MultiplexingBackendTarget)
            return;

        let nextSibling = this._mainExecutionContextPathComponent ? this._mainExecutionContextPathComponent.nextSibling : null;

        this._mainExecutionContextPathComponent = this._createExecutionContextPathComponent(WI.mainTarget.executionContext);
        this._mainExecutionContextPathComponent.previousSibling = this._automaticExecutionContextPathComponent;
        this._mainExecutionContextPathComponent.nextSibling = nextSibling;

        this._automaticExecutionContextPathComponent.nextSibling = this._mainExecutionContextPathComponent;

        this._shouldAutomaticallySelectExecutionContext = true;
        this._selectExecutionContext(WI.mainTarget.executionContext);
        this._rebuildExecutionContextPathComponents();
    }

    // Protected

    layout()
    {
        // A hard maximum size of 33% of the window.
        let maximumAllowedHeight = Math.round(window.innerHeight * 0.33);
        this.prompt.element.style.maxHeight = maximumAllowedHeight + "px";
    }

    // Private

    _displayNameForExecutionContext(context, maxLength = Infinity)
    {
        function truncate(string, length) {
            if (!Number.isFinite(maxLength))
                return string;
            return string.trim().truncateMiddle(length);
        }

        if (context.type === WI.ExecutionContext.Type.Internal)
            return WI.unlocalizedString("[Internal] ") + context.name;
        let preferredName = null;

        let target = context.target;
        if (target.type === WI.TargetType.Worker)
            return truncate(target.displayName, maxLength);

        let frame = context.frame;
        if (frame) {
            if (context === frame.executionContextList.pageExecutionContext) {
                let resourceName = frame.mainResource.displayName;
                let frameName = frame.name;
                if (frameName) {
                    // Attempt to show all of the frame name, but ensure that at least 20 characters
                    // of the resource name are shown as well.
                    let frameNameMaxLength = Math.max(maxLength - resourceName.length, 20);
                    return WI.UIString("%s (%s)").format(truncate(frameName, frameNameMaxLength), truncate(resourceName, maxLength - frameNameMaxLength));
                }
                return truncate(resourceName, maxLength);
            }
        }

        return truncate(context.name, maxLength);
            executionContext = WI.mainTarget.executionContext;

        this._automaticExecutionContextPathComponent.displayName = WI.UIString("Auto - %s").format(preferredName || executionContext.name);

        let changed = WI.runtimeManager.activeExecutionContext !== executionContext;
        if (changed)
            WI.runtimeManager.activeExecutionContext = executionContext;
        return changed;
    }

    _resolveDesiredActiveExecutionContext(forceInspectedNode)
    {
        let executionContext = null;

        if (this._useExecutionContextOfInspectedNode || forceInspectedNode) {
            let inspectedNode = WI.domManager.inspectedNode;
            if (inspectedNode) {
                let frame = inspectedNode.frame;
                if (frame) {
                    let pageExecutionContext = frame.pageExecutionContext;
                    if (pageExecutionContext)
                        executionContext = pageExecutionContext;
                }
            }
        }

        if (!executionContext && WI.networkManager.mainFrame)
            executionContext = WI.networkManager.mainFrame.pageExecutionContext;

        return executionContext || WI.mainTarget.executionContext;
    }

    _setActiveExecutionContext(context)
    {
        let wasActive = WI.runtimeManager.activeExecutionContext === context;

        WI.runtimeManager.activeExecutionContext = context;

        if (wasActive)
            this._updateActiveExecutionContextDisplay();
    }

    _updateActiveExecutionContextDisplay()
    {
        let toggleHidden = (hidden) => {
            this._activeExecutionContextNavigationItemDivider.hidden = hidden;
            this._activeExecutionContextNavigationItem.hidden = hidden;
        };

        if (WI.debuggerManager.activeCallFrame) {
            toggleHidden(true);
            return;
        }

        if (!WI.runtimeManager.activeExecutionContext || !WI.networkManager.mainFrame) {
            toggleHidden(true);
            return;
        }

        if (WI.networkManager.frames.length === 1 && WI.networkManager.mainFrame.executionContextList.contexts.length === 1 && !WI.targetManager.workerTargets.length) {
            toggleHidden(true);
            return;
        }

        const maxLength = 40;

        if (this._useExecutionContextOfInspectedNode) {
            this._activeExecutionContextNavigationItem.element.classList.add("automatic");
            this._activeExecutionContextNavigationItem.element.textContent = WI.UIString("Auto \u2014 %s").format(this._displayNameForExecutionContext(WI.runtimeManager.activeExecutionContext, maxLength));
            this._activeExecutionContextNavigationItem.tooltip = WI.UIString("Execution context for %s").format(WI.RuntimeManager.preferredSavedResultPrefix() + "0");
        } else {
            this._activeExecutionContextNavigationItem.element.classList.remove("automatic");
            this._activeExecutionContextNavigationItem.element.textContent = this._displayNameForExecutionContext(WI.runtimeManager.activeExecutionContext, maxLength);
            this._activeExecutionContextNavigationItem.tooltip = this._displayNameForExecutionContext(WI.runtimeManager.activeExecutionContext);
        }

        this._activeExecutionContextNavigationItem.element.appendChild(WI.ImageUtilities.useSVGSymbol("Images/UpDownArrows.svg", "selector-arrows"));

        toggleHidden(false);
    }

    _populateActiveExecutionContextNavigationItemContextMenu(contextMenu)
    {
        const maxLength = 120;

        let activeExecutionContext = WI.runtimeManager.activeExecutionContext;

        if (InspectorBackend.hasDomain("DOM")) {
            let executionContextForInspectedNode = this._resolveDesiredActiveExecutionContext(true);
            contextMenu.appendCheckboxItem(WI.UIString("Auto \u2014 %s").format(this._displayNameForExecutionContext(executionContextForInspectedNode, maxLength)), () => {
                this._useExecutionContextOfInspectedNode = true;
                this._setActiveExecutionContext(executionContextForInspectedNode);
            }, this._useExecutionContextOfInspectedNode);

            contextMenu.appendSeparator();
        }

        let indent = 0;
        let addExecutionContext = (context) => {
            if (context.type === WI.ExecutionContext.Type.Internal && !WI.settings.engineeringShowInternalExecutionContexts.value)
                return;

            let additionalIndent = (context.frame && context !== context.frame.executionContextList.pageExecutionContext) || context.type !== WI.ExecutionContext.Type.Normal;

            // Mimic macOS `-[NSMenuItem setIndentationLevel]`.
            contextMenu.appendCheckboxItem("   ".repeat(indent + additionalIndent) + this._displayNameForExecutionContext(context, maxLength), () => {
                this._useExecutionContextOfInspectedNode = false;
                this._setActiveExecutionContext(context);
            }, activeExecutionContext === context);
        };

        let addExecutionContextsForFrame = (frame) => {
            let pageExecutionContext = frame.executionContextList.pageExecutionContext;

            let contexts = frame.executionContextList.contexts.sort((a, b) => {
                if (a === pageExecutionContext)
                    return -1;
                if (b === pageExecutionContext)
                    return 1;

                const executionContextTypeRanking = [
                    WI.ExecutionContext.Type.Normal,
                    WI.ExecutionContext.Type.User,
                    WI.ExecutionContext.Type.Internal,
                ];
                return executionContextTypeRanking.indexOf(a.type) - executionContextTypeRanking.indexOf(b.type);
            });
            for (let context of contexts)
                addExecutionContext(context);
        };

        let mainFrame = WI.networkManager.mainFrame;
        addExecutionContextsForFrame(mainFrame);

        indent = 1;

        let otherFrames = WI.networkManager.frames.filter((frame) => frame !== mainFrame && frame.executionContextList.pageExecutionContext);
        if (otherFrames.length) {
            contextMenu.appendHeader(WI.UIString("Frames"));

            for (let frame of otherFrames)
                addExecutionContextsForFrame(frame);
        }

        let workerTargets = WI.targetManager.workerTargets;
        if (workerTargets.length) {
            contextMenu.appendHeader(WI.UIString("Workers"));

            for (let target of workerTargets)
                addExecutionContext(target.executionContext);
        }
    }

    _handleMouseDown(event)

        }
    }

    _handleConsoleSavedResultAliasSettingChanged()
    {
        this._updateActiveExecutionContextDisplay();
        if (WI.debuggerManager.activeCallFrame)
            return [];

        // If there is only the Main ExecutionContext, don't show the selector.
        if (!this._otherExecutionContextPathComponents.length)
            return [];

        if (this._shouldAutomaticallySelectExecutionContext)
            return [this._automaticExecutionContextPathComponent];

        if (WI.runtimeManager.activeExecutionContext === WI.mainTarget.executionContext)
            return [this._mainExecutionContextPathComponent];

        return this._otherExecutionContextPathComponents.filter((component) => component.representedObject === WI.runtimeManager.activeExecutionContext);
    }

    _handleEngineeringShowInternalExecutionContextsSettingChanged(event)
    {
        if (WI.runtimeManager.activeExecutionContext.type !== WI.ExecutionContext.Type.Internal)
            return;

        this._executionContextSelectorItem.element.classList.toggle("automatic-execution-context", this._shouldAutomaticallySelectExecutionContext);
        this._executionContextSelectorItem.components = components;

        this._executionContextSelectorItem.hidden = isEmpty;
        this._executionContextSelectorDivider.hidden = isEmpty;

        this._useExecutionContextOfInspectedNode = InspectorBackend.hasDomain("DOM");
        this._setActiveExecutionContext(this._resolveDesiredActiveExecutionContext());
    }

    _handleFramePageExecutionContextChanged(event)
    {
        if (this._restoreSelectedExecutionContextForFrame !== event.target)
            return;

        this._restoreSelectedExecutionContextForFrame = null;

        let {context} = event.data;
            this._restoreSelectedExecutionContextForFrame = null;

        this._useExecutionContextOfInspectedNode = false;
        this._setActiveExecutionContext(context);
    }

    _handleFrameExecutionContextsCleared(event)
    {
        let {committingProvisionalLoad, contexts} = event.data;

        let hasActiveExecutionContext = contexts.some((context) => context === WI.runtimeManager.activeExecutionContext);
        if (!hasActiveExecutionContext)
            return;

        // If this frame is navigating and it is selected in the UI we want to reselect its new item after navigation.
        if (committingProvisionalLoad && !this._restoreSelectedExecutionContextForFrame) {
            this._restoreSelectedExecutionContextForFrame = event.target;
            if (executionContextPathComponent && executionContextPathComponent.representedObject === WI.runtimeManager.activeExecutionContext) {
                this._restoreSelectedExecutionContextForFrame = frame;
                // As a fail safe, if the frame never gets an execution context, clear the restore value.
                setTimeout(() => {
                    this._restoreSelectedExecutionContextForFrame = false;
                }, 10);
            }
        }

            // As a fail safe, if the frame never gets an execution context, clear the restore value.
            setTimeout(() => {
                this._restoreSelectedExecutionContextForFrame = null;
            }, 10);
    {
        this._rebuildExecutionContextPathComponents();
    }

    _createExecutionContextPathComponent(executionContext, preferredName)
    {
        console.assert(!executionContext || executionContext instanceof WI.ExecutionContext);

        let pathComponent = new WI.HierarchicalPathComponent(preferredName || executionContext.name, "execution-context", executionContext, true, true);
        pathComponent.addEventListener(WI.HierarchicalPathComponent.Event.SiblingWasSelected, this._pathComponentSelected, this);
        pathComponent.addEventListener(WI.HierarchicalPathComponent.Event.Clicked, this._pathComponentClicked, this);
        pathComponent.truncatedDisplayNameLength = 50;
        return pathComponent;
    }

    _compareExecutionContextPathComponents(a, b)
    {
        let aExecutionContext = a.representedObject;
        let bExecutionContext = b.representedObject;

        // "Targets" (workers) at the top.
        let aNonMainTarget = aExecutionContext.target !== WI.mainTarget;
        let bNonMainTarget = bExecutionContext.target !== WI.mainTarget;
        if (aNonMainTarget && !bNonMainTarget)
            return -1;
        if (bNonMainTarget && !aNonMainTarget)
            return 1;
        if (aNonMainTarget && bNonMainTarget)
            return a.displayName.extendedLocaleCompare(b.displayName);

        // "Main Frame" follows.
        if (aExecutionContext === WI.mainTarget.executionContext)
            return -1;
        if (bExecutionContext === WI.mainTarget.executionContext)
            return 1;

        // Only Frame contexts remain.
        console.assert(aExecutionContext.frame);
        console.assert(bExecutionContext.frame);

        // Frames with a name above frames without a name.
        if (aExecutionContext.frame.name && !bExecutionContext.frame.name)
            return -1;
        if (!aExecutionContext.frame.name && bExecutionContext.frame.name)
            return 1;

        return a.displayName.extendedLocaleCompare(b.displayName);
    }

    _insertOtherExecutionContextPathComponent(executionContextPathComponent)
    {
        let index = insertionIndexForObjectInListSortedByFunction(executionContextPathComponent, this._otherExecutionContextPathComponents, this._compareExecutionContextPathComponents);

        let prev = index > 0 ? this._otherExecutionContextPathComponents[index - 1] : this._mainExecutionContextPathComponent;
        let next = this._otherExecutionContextPathComponents[index] || null;
        if (prev) {
            prev.nextSibling = executionContextPathComponent;
            executionContextPathComponent.previousSibling = prev;
        }
        if (next) {
            next.previousSibling = executionContextPathComponent;
            executionContextPathComponent.nextSibling = next;
        }

        this._otherExecutionContextPathComponents.splice(index, 0, executionContextPathComponent);

        this._rebuildExecutionContextPathComponents();
    }

    _removeOtherExecutionContextPathComponent(executionContextPathComponent)
    {
        executionContextPathComponent.removeEventListener(WI.HierarchicalPathComponent.Event.SiblingWasSelected, this._pathComponentSelected, this);
        executionContextPathComponent.removeEventListener(WI.HierarchicalPathComponent.Event.Clicked, this._pathComponentClicked, this);

        let prev = executionContextPathComponent.previousSibling;
        let next = executionContextPathComponent.nextSibling;
        if (prev)
            prev.nextSibling = next;
        if (next)
            next.previousSibling = prev;

        this._otherExecutionContextPathComponents.remove(executionContextPathComponent, true);

        this._rebuildExecutionContextPathComponents();
    }

    _insertExecutionContextPathComponentForFrame(frame)
    {
        if (frame.isMainFrame())
            return this._mainExecutionContextPathComponent;

        let executionContextPathComponent = this._createExecutionContextPathComponent(frame.pageExecutionContext, this._preferredNameForFrame(frame));
        this._insertOtherExecutionContextPathComponent(executionContextPathComponent);
        this._frameToPathComponent.set(frame, executionContextPathComponent);
        return executionContextPathComponent;
    }

    _removeExecutionContextPathComponentForFrame(frame)
    {
        if (frame.isMainFrame()) {
            this._shouldAutomaticallySelectExecutionContext = true;
            this._initializeMainExecutionContextPathComponent();
            return;
        }

        this._useExecutionContextOfInspectedNode = InspectorBackend.hasDomain("DOM");
        this._setActiveExecutionContext(this._resolveDesiredActiveExecutionContext());
    }

    _handleDebuggerActiveCallFrameDidChange(event)
    {
        this._updateActiveExecutionContextDisplay();
    }

    _handleActiveExecutionContextChanged(event)
    {
        this._updateActiveExecutionContextDisplay();
    }

    _handleTransitionPageTarget()
    {
        this._updateActiveExecutionContextDisplay();
    }

    _handleTargetRemoved(event)
    {
        let {target} = event.data;
        if (target !== WI.runtimeManager.activeExecutionContext)
            return;

        this._useExecutionContextOfInspectedNode = InspectorBackend.hasDomain("DOM");
        this._setActiveExecutionContext(this._resolveDesiredActiveExecutionContext());
        let executionContextPathComponent = this._createExecutionContextPathComponent(target.executionContext, preferredName);

        this._targetToPathComponent.set(target, executionContextPathComponent);
        this._insertOtherExecutionContextPathComponent(executionContextPathComponent);
    }

    _handleInspectedNodeChanged(event)
    {
        if (!this._useExecutionContextOfInspectedNode)
        if (target.type !== WI.TargetType.Worker)
            return;

        this._setActiveExecutionContext(this._resolveDesiredActiveExecutionContext());

        if (WI.runtimeManager.activeExecutionContext === executionContextPathComponent.representedObject) {
            this._shouldAutomaticallySelectExecutionContext = true;
            this._selectExecutionContext();
        }

        this._removeOtherExecutionContextPathComponent(executionContextPathComponent);
    }

    _pathComponentSelected(event)
    {
        this._shouldAutomaticallySelectExecutionContext = event.data.pathComponent === this._automaticExecutionContextPathComponent;

        // Only manually rebuild the execution context path components if the newly selected
        // execution context matches the previously selected one.
        if (!this._selectExecutionContext(event.data.pathComponent.representedObject))
            this._rebuildExecutionContextPathComponents();
    }

    _pathComponentClicked(event)
    {
        this.prompt.focus();
    }

    _debuggerActiveCallFrameDidChange(event)
    {
        this._rebuildExecutionContextPathComponents();
    }

    _toggleOrFocus(event)

    {
        this.element.classList.toggle("showing-log", WI.isShowingConsoleTab() || WI.isShowingSplitConsole());
    }

    _handleInspectedNodeChanged(event)
    {
        this._selectExecutionContext(WI.runtimeManager.activeExecutionContext);
    }
};



/*
 * Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

WI.QuickConsoleNavigationBar = class QuickConsoleNavigationBar extends WI.NavigationBar
{
    get sizesToFit()
    {
        return true;
    }

    addNavigationItem(navigationItem)
    {
        // Add new navigation items to the left.
        return this.insertNavigationItem(navigationItem, 0);
    }
};

Lines 405-411 WI.SettingsTabContentView = class SettingsTabContentView extends WI.TabContentVi a/Source/WebInspectorUI/UserInterface/Views/SettingsTabContentView.js_sec1
- a/Source/WebInspectorUI/UserInterface/Views/SettingsTabContentView.js +3 lines
405	let elementsGroup = engineeringSettingsView.addGroup(WI.unlocalizedString("Elements:"));	405	let elementsGroup = engineeringSettingsView.addGroup(WI.unlocalizedString("Elements:"));
406	elementsGroup.addSetting(WI.settings.engineeringAllowEditingUserAgentShadowTrees, WI.unlocalizedString("Allow editing UserAgent shadow trees"));	406	elementsGroup.addSetting(WI.settings.engineeringAllowEditingUserAgentShadowTrees, WI.unlocalizedString("Allow editing UserAgent shadow trees"));
407		407
		408	engineeringSettingsView.addSeparator();
		409
408	let debuggingGroup = engineeringSettingsView.addGroup(WI.unlocalizedString("Debugging:"));	410	let debuggingGroup = engineeringSettingsView.addGroup(WI.unlocalizedString("Debugging:"));
		411	debuggingGroup.addSetting(WI.settings.engineeringShowInternalExecutionContexts, WI.unlocalizedString("Show WebKit-internal execution contexts"));
409	debuggingGroup.addSetting(WI.settings.engineeringShowInternalScripts, WI.unlocalizedString("Show WebKit-internal scripts"));	412	debuggingGroup.addSetting(WI.settings.engineeringShowInternalScripts, WI.unlocalizedString("Show WebKit-internal scripts"));
410	debuggingGroup.addSetting(WI.settings.engineeringPauseForInternalScripts, WI.unlocalizedString("Pause in WebKit-internal scripts"));	413	debuggingGroup.addSetting(WI.settings.engineeringPauseForInternalScripts, WI.unlocalizedString("Pause in WebKit-internal scripts"));
411		414



/*
 * Copyright (C) 2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

WI.SizesToFitNavigationBar = class SizesToFitNavigationBar extends WI.NavigationBar
{
    get sizesToFit()
    {
        return true;
    }
};



 */
WebKitScriptWorld* webkit_script_world_new(void)
{
    return webkitScriptWorldCreate(InjectedBundleScriptWorld::create(InjectedBundleScriptWorld::Type::User));
}

/**

{
    g_return_val_if_fail(name, nullptr);

    return webkitScriptWorldCreate(InjectedBundleScriptWorld::create(String::fromUTF8(name), InjectedBundleScriptWorld::Type::User));
}

/**



    return makeString("UniqueWorld_", uniqueWorldNameNumber++);
}

Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create(Type type)
{
    return InjectedBundleScriptWorld::create(uniqueWorldName(), type);
}

Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create(const String& name, Type type)
{
    return adoptRef(*new InjectedBundleScriptWorld(ScriptController::createWorld(name, type == Type::User ? ScriptController::WorldType::User : ScriptController::WorldType::Internal), name));
}

Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::getOrCreate(DOMWrapperWorld& world)




class InjectedBundleScriptWorld : public API::ObjectImpl<API::Object::Type::BundleScriptWorld> {
public:
    enum class Type { User, Internal };
    static Ref<InjectedBundleScriptWorld> create(Type = Type::Internal);
    static Ref<InjectedBundleScriptWorld> create(const String& name, Type = Type::Internal);
    static Ref<InjectedBundleScriptWorld> getOrCreate(WebCore::DOMWrapperWorld&);
    static InjectedBundleScriptWorld* find(const String&);
    static InjectedBundleScriptWorld& normalWorld();

Lines 115-121 void WebUserContentController::addUserContentWorld(const std::pair<ContentWorldI a/Source/WebKit/WebProcess/UserContent/WebUserContentController.cpp_sec1
- a/Source/WebKit/WebProcess/UserContent/WebUserContentController.cpp -1 / +1 lines
115	if (auto* existingWorld = InjectedBundleScriptWorld::find(world.second))	115	if (auto* existingWorld = InjectedBundleScriptWorld::find(world.second))
116	return std::make_pair(Ref<InjectedBundleScriptWorld>(*existingWorld), 1);	116	return std::make_pair(Ref<InjectedBundleScriptWorld>(*existingWorld), 1);
117	#endif	117	#endif
118	return std::make_pair(InjectedBundleScriptWorld::create(world.second), 1);	118	return std::make_pair(InjectedBundleScriptWorld::create(world.second, InjectedBundleScriptWorld::Type::User), 1);
119	});	119	});
120	}	120	}
121		121

Lines 66-72 - (id)initWithWorld:(Ref<WebCore::DOMWrapperWorld>&&)world a/Source/WebKitLegacy/mac/WebView/WebScriptWorld.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebScriptWorld.mm -1 / +1 lines
66		66
67	- (id)init	67	- (id)init
68	{	68	{
69	return [self initWithWorld:WebCore::ScriptController::createWorld()];	69	return [self initWithWorld:WebCore::ScriptController::createWorld("WebScriptWorld"_s, WebCore::ScriptController::WorldType::User)];
70	}	70	}
71		71
72	- (void)unregisterWorld	72	- (void)unregisterWorld

Lines 67-73 WebScriptWorld* WebScriptWorld::standardWorld() a/Source/WebKitLegacy/win/WebScriptWorld.cpp_sec1
- a/Source/WebKitLegacy/win/WebScriptWorld.cpp -1 / +1 lines
67		67
68	COMPtr<WebScriptWorld> WebScriptWorld::createInstance()	68	COMPtr<WebScriptWorld> WebScriptWorld::createInstance()
69	{	69	{
70	return createInstance(ScriptController::createWorld());	70	return createInstance(ScriptController::createWorld("WebScriptWorld"_s, WebCore::ScriptController::WorldType::User));
71	}	71	}
72		72
73	COMPtr<WebScriptWorld> WebScriptWorld::createInstance(RefPtr<DOMWrapperWorld>&& world)	73	COMPtr<WebScriptWorld> WebScriptWorld::createInstance(RefPtr<DOMWrapperWorld>&& world)



2020-02-27  Devin Rousso  <drousso@apple.com>

        Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
        https://bugs.webkit.org/show_bug.cgi?id=206110
        <rdar://problem/16945643>

        Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.

        In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
        to evaluate in non-normal isolated worlds.

        * inspector/runtime/executionContextCreated-isolated-world.html: Added.
        * inspector/runtime/executionContextCreated-isolated-world-expected.txt: Added.

        * inspector/runtime/change-execution-context-identifier.html:
        * inspector/runtime/change-execution-context-identifier-expected.txt:
        Don't expect the active execution context to change when the owner frame is removed, as that
        is now handled by the UI (`WI.QuickConsole`) instead of the `WI.RuntimeManager`.

        * inspector/runtime/executionContextCreated-onEnable.html:
        Ignore internal worlds.

2020-01-26  Said Abou-Hallawa  <said@apple.com>

        Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler

Lines 25-29 PASS: The passphrase should match the phrase defined in the main frame. a/LayoutTests/inspector/runtime/change-execution-context-identifier-expected.txt_sec1
- a/LayoutTests/inspector/runtime/change-execution-context-identifier-expected.txt -1 / +1 lines
25	-- Running test case: ScriptExecutionContextRemoveSubframe	25	-- Running test case: ScriptExecutionContextRemoveSubframe
26	PASS: The test page should only have one sub-frame.	26	PASS: The test page should only have one sub-frame.
27	PASS: The test page should now have no sub-frames.	27	PASS: The test page should now have no sub-frames.
28	PASS: When a selected non-top-level execution context is removed, the active execution context should revert to the main frame context.	28	PASS: When a selected non-top-level execution context is removed, the active execution context should not change, as that is handled by the UI.
29		29




            // Set the execution context to the subframe so we can switch away from it when the frame is detached.
            WI.runtimeManager.activeExecutionContext = subframes[0].pageExecutionContext;
            let activeExecutionContextId = WI.runtimeManager.activeExecutionContext.id;

            // Force-override the contextId, otherwise we won't be able to access the iframe's DOM element when evaluating in the iframe execution context.
            let expression = `document.getElementById("subframe").remove();`;

            let contextId = WI.RuntimeManager.TopLevelExecutionContextIdentifier;
            RuntimeAgent.evaluate.invoke({expression, objectGroup, contextId}, () => {
                InspectorTest.expectEqual(WI.networkManager.frames.length, 1, "The test page should now have no sub-frames.");
                InspectorTest.expectEqual(WI.runtimeManager.activeExecutionContext.id, activeExecutionContextId, "When a selected non-top-level execution context is removed, the active execution context should not change, as that is handled by the UI.");
                resolve();
            });
        }




Test that exactly one Runtime.executionContextCreated event is fired for each existing context when Runtime.enable is called.


== Running test suite: Runtime.executionContextCreated.IsolatedWorld
-- Running test case: Runtime.executionContextCreated.IsolatedWorld.Internal
PASS: Received event for internal isolated world.
PASS: Execution context should be internal.




<html>
<head>
<script src="../../http/tests/inspector/resources/protocol-test.js"></script>
<script src="../../http/tests/inspector/resources/stable-id-map.js"></script>
<script>
function createIsolatedWorld() {
    const name = "InspectorTestInternalIsolatedWorld";
    function source() { return 42; }

    if (window.internals)
        window.internals.evaluateInWorldIgnoringException(name, source.toString());
}

function test()
{
    ProtocolTest.debug();

    let suite = ProtocolTest.createAsyncSuite("Runtime.executionContextCreated.IsolatedWorld");

    suite.addTestCase({
        name: "Runtime.executionContextCreated.IsolatedWorld.Internal",
        description: "Test that Runtime.executionContextCreated events are dispatched for internal isolated worlds.",
        async test() {
            let completion = new WI.WrappedPromise;

            let listener = InspectorProtocol.addEventListener("Runtime.executionContextCreated", (messageObject) => {
                let {id, name, type} = messageObject.params.context;
                if (name !== "InspectorTestInternalIsolatedWorld")
                    return;

                InspectorProtocol.removeEventListener("Runtime.executionContextCreated", listener);

                ProtocolTest.pass("Received event for internal isolated world.");
                ProtocolTest.expectEqual(type, "internal", "Execution context should be internal.");

                completion.resolve();
            });

            await Promise.all([
                InspectorProtocol.awaitCommand({method: "Page.enable"}),
                InspectorProtocol.awaitCommand({method: "Runtime.enable"}),
            ]);

            await InspectorProtocol.awaitCommand({
                method: "Runtime.evaluate",
                params: {
                    expression: `createIsolatedWorld()`,
                },
            });

            await completion.promise;
        },
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body>
<iframe id="subframe" src="resources/change-execution-context-identifier-subframe.html" onload="runTest()"></iframe>
<p>Test that exactly one Runtime.executionContextCreated event is fired for each existing context when Runtime.enable is called.</p>
</body>
</html>

Lines 16-23 function test() a/LayoutTests/inspector/runtime/executionContextCreated-onEnable.html_sec1
- a/LayoutTests/inspector/runtime/executionContextCreated-onEnable.html -2 / +5 lines
16	let contextCount = 0;	16	let contextCount = 0;
17		17
18	InspectorProtocol.addEventListener("Runtime.executionContextCreated", (messageObject) => {	18	InspectorProtocol.addEventListener("Runtime.executionContextCreated", (messageObject) => {
19	let {id, isPageContext, frameId} = messageObject.params.context;	19	let {id, type, frameId} = messageObject.params.context;
20	ProtocolTest.log(`Execution context created: id=${contextIdMap.get(id)} frameId=${frameIdMap.get(frameId)} isPageContext=${isPageContext}`)	20	if (type === "internal")
		21	return;
		22
		23	ProtocolTest.log(`Execution context created: id=${contextIdMap.get(id)} frameId=${frameIdMap.get(frameId)} isPageContext=${type === "normal"}`)
21	++contextCount;	24	++contextCount;
22	});	25	});
23		26

Return to Bug 206110

Lines 976-991 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec1
- a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js -4 / +4 lines
976		976
977	// RuntimeObserver	977	// RuntimeObserver
978		978
979	executionContextCreated(contextPayload)	979	executionContextCreated(payload)
980	{	980	{
981	let frame = this.frameForIdentifier(contextPayload.frameId);	981	let frame = this.frameForIdentifier(payload.frameId);
982	console.assert(frame);	982	console.assert(frame);
983	if (!frame)	983	if (!frame)
984	return;	984	return;
985		985
986	let displayName = contextPayload.name \|\| frame.mainResource.displayName;	986	let type = WI.ExecutionContext.typeFromPayload(payload);
987	let target = frame.mainResource.target;	987	let target = frame.mainResource.target;
988	let executionContext = new WI.ExecutionContext(target, contextPayload.id, displayName, contextPayload.isPageContext, frame);	988	let executionContext = new WI.ExecutionContext(target, payload.id, type, payload.name, frame);
989	frame.addExecutionContext(executionContext);	989	frame.addExecutionContext(executionContext);
990	}	990	}
991		991

Lines 152-158 WebKitScriptWorld* webkit_script_world_get_default(void) a/Source/WebKit/WebProcess/InjectedBundle/API/glib/WebKitScriptWorld.cpp_sec1
- a/Source/WebKit/WebProcess/InjectedBundle/API/glib/WebKitScriptWorld.cpp -2 / +2 lines
152	*/	152	*/
153	WebKitScriptWorld* webkit_script_world_new(void)	153	WebKitScriptWorld* webkit_script_world_new(void)
154	{	154	{
155	return webkitScriptWorldCreate(InjectedBundleScriptWorld::create());	155	return webkitScriptWorldCreate(InjectedBundleScriptWorld::create(InjectedBundleScriptWorld::Type::User));
156	}	156	}
157		157
158	/**	158	/**
Lines 173-179 WebKitScriptWorld* webkit_script_world_new_with_name(const char* name) a/Source/WebKit/WebProcess/InjectedBundle/API/glib/WebKitScriptWorld.cpp_sec2
173	{	173	{
174	g_return_val_if_fail(name, nullptr);	174	g_return_val_if_fail(name, nullptr);
175		175
176	return webkitScriptWorldCreate(InjectedBundleScriptWorld::create(String::fromUTF8(name)));	176	return webkitScriptWorldCreate(InjectedBundleScriptWorld::create(String::fromUTF8(name), InjectedBundleScriptWorld::Type::User));
177	}	177	}
178		178
179	/**	179	/**

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +15 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* inspector/protocol/Runtime.json:
		13	Introduce an `ExecutionContextType` enum instead of `isPageContext` so the frontend can
		14	decide whether/how to show a picker for that execution context.
		15
1	2020-01-26 Alexey Shvayka <shvaikalesh@gmail.com>	16	2020-01-26 Alexey Shvayka <shvaikalesh@gmail.com>
2		17
3	Invalid ranges in character classes should be banned in unicode patterns	18	Invalid ranges in character classes should be banned in unicode patterns

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +57 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	Test: inspector/runtime/executionContextCreated-isolated-world.html
		13
		14	* bindings/js/DOMWrapperWorld.h:
		15	(WebCore::DOMWrapperWorld::create):
		16	(WebCore::DOMWrapperWorld::type const): Added.
		17	(WebCore::DOMWrapperWorld::isNormal const):
		18	(WebCore::DOMWrapperWorld::name const): Added.
		19	* bindings/js/DOMWrapperWorld.cpp:
		20	(WebCore::DOMWrapperWorld::DOMWrapperWorld):
		21	* bindings/js/ScriptController.h:
		22	* bindings/js/ScriptController.cpp:
		23	(WebCore::ScriptController::createWorld):
		24	* bindings/js/WebCoreJSClientData.cpp:
		25	(WebCore::JSVMClientData::initNormalWorld):
		26	Require that a name is specified when creating an isolated world (except the normal world)
		27	so that Web Inspector has something to show in the execution context picker.
		28
		29	* inspector/InspectorInstrumentation.cpp:
		30	(WebCore::InspectorInstrumentation::didClearWindowObjectInWorldImpl):
		31	* inspector/agents/InspectorPageAgent.h:
		32	* inspector/agents/InspectorPageAgent.cpp:
		33	(WebCore::InspectorPageAgent::didClearWindowObjectInWorld):
		34	* inspector/agents/page/PageDebuggerAgent.h:
		35	* inspector/agents/page/PageDebuggerAgent.cpp:
		36	(WebCore::PageDebuggerAgent::didClearWindowObjectInWorld):
		37	* inspector/agents/page/PageRuntimeAgent.h:
		38	* inspector/agents/page/PageRuntimeAgent.cpp:
		39	(WebCore::PageRuntimeAgent::didClearWindowObjectInWorld):
		40	(WebCore::PageRuntimeAgent::reportExecutionContextCreation):
		41	(WebCore::toProtocol): Added.
		42	(WebCore::PageRuntimeAgent::notifyContextCreated):
		43	Allow this instrumentation call to pass through to the agents for non-`Normal` worlds.
		44
		45	* html/HTMLMediaElement.cpp:
		46	(WebCore::HTMLMediaElement::ensureIsolatedWorld):
		47	* html/HTMLPlugInImageElement.cpp:
		48	(WebCore::plugInImageElementIsolatedWorld):
		49	* Modules/plugins/QuickTimePluginReplacement.mm:
		50	(WebCore::QuickTimePluginReplacement::isolatedWorld):
		51	Mark these worlds as `Internal`.
		52
		53	* testing/Internals.idl:
		54	* testing/Internals.h:
		55	* testing/Internals.cpp:
		56	(WebCore::Internals::evaluateInWorldIgnoringException): Added.
		57
1	2020-01-26 youenn fablet <youenn@apple.com>	58	2020-01-26 youenn fablet <youenn@apple.com>
2		59
3	Use ObjectIdentifier for remote RealtimeMediaSource	60	Use ObjectIdentifier for remote RealtimeMediaSource

Lines 1-3 a/Source/WebInspectorUI/ChangeLog_sec1
- a/Source/WebInspectorUI/ChangeLog +143 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* UserInterface/Models/ExecutionContext.js:
		13	(WI.ExecutionContext):
		14	(WI.ExecutionContext.typeFromPayload): Added.
		15	(WI.ExecutionContext.prototype.get type): Added.
		16	(WI.ExecutionContext.prototype.get isPageContext): Deleted.
		17
		18	* UserInterface/Models/ExecutionContextList.js:
		19	(WI.ExecutionContextList.prototype.add):
		20	* UserInterface/Models/Frame.js:
		21	(WI.Frame.prototype.addExecutionContext):
		22	* UserInterface/Controllers/NetworkManager.js:
		23	(WI.NetworkManager.prototype.executionContextCreated):
		24	The `Normal` execution context (of which there should only be one) is considered the "page"
		25	execution context.
		26
		27	* UserInterface/Protocol/DirectBackendTarget.js:
		28	(WI.DirectBackendTarget):
		29	* UserInterface/Protocol/PageTarget.js:
		30	(WI.PageTarget):
		31	* UserInterface/Protocol/WorkerTarget.js:
		32	(WI.WorkerTarget):
		33	Default to a `Normal` execution context.
		34
		35	* UserInterface/Views/QuickConsole.js:
		36	(WI.QuickConsole):
		37	(WI.QuickConsole.prototype._displayNameForExecutionContext): Added.
		38	(WI.QuickConsole.prototype._resolveDesiredActiveExecutionContext): Added.
		39	(WI.QuickConsole.prototype._setActiveExecutionContext): Added.
		40	(WI.QuickConsole.prototype._updateActiveExecutionContextDisplay): Added.
		41	(WI.QuickConsole.prototype._populateActiveExecutionContextNavigationItemContextMenu): Added.
		42	(WI.QuickConsole.prototype._handleConsoleSavedResultAliasSettingChanged): Added.
		43	(WI.QuickConsole.prototype._handleEngineeringShowInternalExecutionContextsSettingChanged): Added.
		44	(WI.QuickConsole.prototype._handleFramePageExecutionContextChanged): Added.
		45	(WI.QuickConsole.prototype._handleFrameExecutionContextsCleared): Added.
		46	(WI.QuickConsole.prototype._handleDebuggerActiveCallFrameDidChange): Added.
		47	(WI.QuickConsole.prototype._handleActiveExecutionContextChanged): Added.
		48	(WI.QuickConsole.prototype._handleTransitionPageTarget): Added.
		49	(WI.QuickConsole.prototype._handleTargetRemoved): Added.
		50	(WI.QuickConsole.prototype._handleInspectedNodeChanged): Added.
		51	(WI.QuickConsole.prototype._updateStyles):
		52	(WI.QuickConsole.prototype.get navigationBar): Deleted.
		53	(WI.QuickConsole.prototype._pageTargetTransitioned): Deleted.
		54	(WI.QuickConsole.prototype._initializeMainExecutionContextPathComponent): Deleted.
		55	(WI.QuickConsole.prototype.layout): Deleted.
		56	(WI.QuickConsole.prototype._preferredNameForFrame): Deleted.
		57	(WI.QuickConsole.prototype._selectExecutionContext): Deleted.
		58	(WI.QuickConsole.prototype._updateAutomaticExecutionContextPathComponentTooltip): Deleted.
		59	(WI.QuickConsole.prototype._executionContextPathComponentsToDisplay): Deleted.
		60	(WI.QuickConsole.prototype._rebuildExecutionContextPathComponents): Deleted.
		61	(WI.QuickConsole.prototype._framePageExecutionContextsChanged): Deleted.
		62	(WI.QuickConsole.prototype._frameExecutionContextsCleared): Deleted.
		63	(WI.QuickConsole.prototype._activeExecutionContextChanged): Deleted.
		64	(WI.QuickConsole.prototype._createExecutionContextPathComponent): Deleted.
65	(WI.QuickConsole.prototype._compareExecutionContextPathComponents): Deleted.
66	(WI.QuickConsole.prototype._insertOtherExecutionContextPathComponent): Deleted.
67	(WI.QuickConsole.prototype._removeOtherExecutionContextPathComponent): Deleted.
68	(WI.QuickConsole.prototype._insertExecutionContextPathComponentForFrame): Deleted.
69	(WI.QuickConsole.prototype._removeExecutionContextPathComponentForFrame): Deleted.
70	(WI.QuickConsole.prototype._targetAdded): Deleted.
71	(WI.QuickConsole.prototype._targetRemoved): Deleted.
72	(WI.QuickConsole.prototype._pathComponentSelected): Deleted.
73	(WI.QuickConsole.prototype._pathComponentClicked): Deleted.
74	(WI.QuickConsole.prototype._debuggerActiveCallFrameDidChange): Deleted.
75	* UserInterface/Views/QuickConsole.css:
76	(.quick-console > .console-prompt):
77	(.quick-console > .navigation-bar):
78	(.quick-console > .navigation-bar .active-execution-context): Added.
79	(.quick-console > .navigation-bar .active-execution-context > .selector-arrows): Added.
80	(.quick-console > .navigation-bar .active-execution-context:not(.automatic)): Added.
81	(.quick-console > .navigation-bar .active-execution-context:not(.automatic) > .selector-arrows): Added.
82	(.quick-console .execution-context): Deleted.
83	(.quick-console > .navigation-bar > .hierarchical-path .execution-context): Deleted.
84	(.quick-console > .navigation-bar > .hierarchical-path .execution-context .separator): Deleted.
85	(.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context)): Deleted.
86	(.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context): Deleted.
87	(.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context .selector-arrows): Deleted.
88	Replace the `WI.HierarchicalPathNavigationItem` with a plain `WI.NavigationItem` that shows
89	a `WI.ContextMenu` with all valid execution contexts organized as follows:
90
91	Auto - <display name for execution context of inspected DOM node>
92	----------
93	Main Frame Normal Execution Context
94	All User Exection Contexts for the Main Frame
95	All Internal Exection Contexts for the Main Frame (with the engineering setting)
96	Frames
97	Frame Normal Execution Context
98	All User Exection Contexts for the Frame
99	All Internal Exection Contexts for the Frame (with the engineering setting)
100	...
101	Workers
102	Worker Execution Context
103	...
104
105	Everything is checkmark selectable other than the separator, "Frames", and "Workers".
106
107	* UserInterface/Controllers/RuntimeManager.js:
108	(WI.RuntimeManager):
109	(WI.RuntimeManager.prototype._frameExecutionContextsCleared): Deleted.
110	Let the UI (`WI.QuickConsole`) decide when to automatically update the active execution
111	context when a frame is removed that owned the active execution context.
112
113	* UserInterface/Controllers/TargetManager.js:
114	(WI.TargetManager.prototype.get workerTargets): Added.
115	(WI.TargetManager.prototype._terminatePageTarget):
116	Convenience function for getting the list of worker targets.
117
118	* UserInterface/Views/GroupNavigationItem.js:
119	(WI.GroupNavigationItem.prototype.update):
120	(WI.GroupNavigationItem.prototype.didAttach):
121	Update the items whenever the group updates.
122
123	* UserInterface/Main.html:
124	* UserInterface/Views/SizesToFitNavigationBar.js: Renamed from Source/WebInspectorUI/UserInterface/Views/QuickConsoleNavigationBar.js.
125	(WI.SizesToFitNavigationBar):
126	(WI.SizesToFitNavigationBar.prototype.get sizesToFit):
127	Rename to allow for other use cases.
128
129	* UserInterface/Views/ContextMenu.js:
130	(WI.ContextSubMenuItem.prototype.appendHeader): Added.
131	Convenience method for creating a disabled item.
132
133	* UserInterface/Base/Setting.js:
134	* UserInterface/Views/SettingsTabContentView.js:
135	(WI.SettingsTabContentView.prototype._createEngineeringSettingsView):
136	Create an engineering setting that controls whether `Internal` execution contexts are shown.
137
138	* UserInterface/Test/InspectorProtocol.js:
139	(InspectorProtocol.addEventListener):
140	(InspectorProtocol.removeEventListener): Added.
141
142	* Localizations/en.lproj/localizedStrings.js:
143
1	2020-01-21 Keith Rollin <krollin@apple.com>	144	2020-01-21 Keith Rollin <krollin@apple.com>
2		145
3	Fix tvOS values in SUPPORTED_PLATFORMS	146	Fix tvOS values in SUPPORTED_PLATFORMS

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +22 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* WebProcess/InjectedBundle/InjectedBundleScriptWorld.h:
		13	* WebProcess/InjectedBundle/InjectedBundleScriptWorld.cpp:
		14	(WebKit::InjectedBundleScriptWorld::create):
		15
		16	* WebProcess/UserContent/WebUserContentController.cpp:
		17	(WebKit::WebUserContentController::addUserContentWorlds):
		18	* WebProcess/InjectedBundle/API/glib/WebKitScriptWorld.cpp:
		19	(webkit_script_world_new):
		20	(webkit_script_world_new_with_name):
		21	Treat isolated worlds created by API calls as `User` worlds.
		22
1	2020-01-26 Chris Dumez <cdumez@apple.com>	23	2020-01-26 Chris Dumez <cdumez@apple.com>
2		24
3	Frequent sync BackForwardBackListCount/BackForwardForwardListCount IPC on reddit.com	25	Frequent sync BackForwardBackListCount/BackForwardForwardListCount IPC on reddit.com

Lines 1-3 a/Source/WebKitLegacy/mac/ChangeLog_sec1
- a/Source/WebKitLegacy/mac/ChangeLog +15 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* WebView/WebScriptWorld.mm:
		13	(-[WebScriptWorld init]):
		14	Treat isolated worlds created by API calls as `User` worlds.
		15
1	2020-01-26 Said Abou-Hallawa <said@apple.com>	16	2020-01-26 Said Abou-Hallawa <said@apple.com>
2		17
3	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler	18	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler

Lines 1-3 a/Source/WebKitLegacy/win/ChangeLog_sec1
- a/Source/WebKitLegacy/win/ChangeLog +15 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* WebScriptWorld.cpp:
		13	(WebScriptWorld::createInstance):
		14	Treat isolated worlds created by API calls as `User` worlds.
		15
1	2020-01-26 Said Abou-Hallawa <said@apple.com>	16	2020-01-26 Said Abou-Hallawa <said@apple.com>
2		17
3	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler	18	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler

Lines 108-120 a/Source/JavaScriptCore/inspector/protocol/Runtime.json_sec1
- a/Source/JavaScriptCore/inspector/protocol/Runtime.json -1 / +7 lines
108	"type": "integer",	108	"type": "integer",
109	"description": "Id of an execution context."	109	"description": "Id of an execution context."
110	},	110	},
		111	{
		112	"id": "ExecutionContextType",
		113	"type": "string",
		114	"enum": ["normal", "user", "internal"],
		115	"description": "Type of the execution context."
		116	},
111	{	117	{
112	"id": "ExecutionContextDescription",	118	"id": "ExecutionContextDescription",
113	"type": "object",	119	"type": "object",
114	"description": "Description of an isolated world.",	120	"description": "Description of an isolated world.",
115	"properties": [	121	"properties": [
116	{ "name": "id", "$ref": "ExecutionContextId", "description": "Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed." },	122	{ "name": "id", "$ref": "ExecutionContextId", "description": "Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed." },
117	{ "name": "isPageContext", "type": "boolean", "description": "True if this is a context where inpspected web page scripts run. False if it is a content script isolated context." },	123	{ "name": "type", "$ref": "ExecutionContextType" },
118	{ "name": "name", "type": "string", "description": "Human readable name describing given context."},	124	{ "name": "name", "type": "string", "description": "Human readable name describing given context."},
119	{ "name": "frameId", "$ref": "Network.FrameId", "description": "Id of the owning frame." }	125	{ "name": "frameId", "$ref": "Network.FrameId", "description": "Id of the owning frame." }
120	]	126	]

Lines 26-31 a/Source/WebCore/bindings/js/ScriptController.cpp_sec1
- a/Source/WebCore/bindings/js/ScriptController.cpp -2 / +3 lines
26	#include "CommonVM.h"	26	#include "CommonVM.h"
27	#include "ContentSecurityPolicy.h"	27	#include "ContentSecurityPolicy.h"
28	#include "CustomHeaderFields.h"	28	#include "CustomHeaderFields.h"
		29	#include "DOMWrapperWorld.h"
29	#include "DocumentLoader.h"	30	#include "DocumentLoader.h"
30	#include "Event.h"	31	#include "Event.h"
31	#include "Frame.h"	32	#include "Frame.h"
Lines 247-255 JSC::JSValue ScriptController::evaluateModule(const URL& sourceURL, JSModuleReco a/Source/WebCore/bindings/js/ScriptController.cpp_sec2
247	return evaluateModule(sourceURL, moduleRecord, mainThreadNormalWorld());	248	return evaluateModule(sourceURL, moduleRecord, mainThreadNormalWorld());
248	}	249	}
249		250
250	Ref<DOMWrapperWorld> ScriptController::createWorld()	251	Ref<DOMWrapperWorld> ScriptController::createWorld(const String& name, WorldType type)
251	{	252	{
252	return DOMWrapperWorld::create(commonVM());	253	return DOMWrapperWorld::create(commonVM(), type == WorldType::User ? DOMWrapperWorld::Type::User : DOMWrapperWorld::Type::Internal, name);
253	}	254	}
254		255
255	void ScriptController::getAllWorlds(Vector<Ref<DOMWrapperWorld>>& worlds)	256	void ScriptController::getAllWorlds(Vector<Ref<DOMWrapperWorld>>& worlds)

Lines 87-93 public: a/Source/WebCore/bindings/js/ScriptController.h_sec1
- a/Source/WebCore/bindings/js/ScriptController.h -2 / +3 lines
87	explicit ScriptController(Frame&);	87	explicit ScriptController(Frame&);
88	~ScriptController();	88	~ScriptController();
89		89
90	WEBCORE_EXPORT static Ref<DOMWrapperWorld> createWorld();	90	enum class WorldType { User, Internal };
		91	WEBCORE_EXPORT static Ref<DOMWrapperWorld> createWorld(const String& name, WorldType = WorldType::Internal);
91		92
92	JSDOMWindow* globalObject(DOMWrapperWorld& world)	93	JSDOMWindow* globalObject(DOMWrapperWorld& world)
93	{	94	{
Lines 104-110 public: a/Source/WebCore/bindings/js/ScriptController.h_sec2
104	WEBCORE_EXPORT ValueOrException executeUserAgentScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture);	105	WEBCORE_EXPORT ValueOrException executeUserAgentScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture);
105	WEBCORE_EXPORT void executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld&, RunJavaScriptParameters&&, ResolveFunction&&);	106	WEBCORE_EXPORT void executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld&, RunJavaScriptParameters&&, ResolveFunction&&);
106	JSC::JSValue evaluateIgnoringException(const ScriptSourceCode&);	107	JSC::JSValue evaluateIgnoringException(const ScriptSourceCode&);
107	JSC::JSValue evaluateInWorldIgnoringException(const ScriptSourceCode&, DOMWrapperWorld&);	108	WEBCORE_EXPORT JSC::JSValue evaluateInWorldIgnoringException(const ScriptSourceCode&, DOMWrapperWorld&);
108		109
109	Expected<void, ExceptionDetails> shouldAllowUserAgentScripts(Document&) const;	110	Expected<void, ExceptionDetails> shouldAllowUserAgentScripts(Document&) const;
110		111

Lines 114-123 void JSVMClientData::initNormalWorld(VM* vm) a/Source/WebCore/bindings/js/WebCoreJSClientData.cpp_sec1
- a/Source/WebCore/bindings/js/WebCoreJSClientData.cpp -3 / +3 lines
114	{	114	{
115	JSVMClientData* clientData = new JSVMClientData(*vm);	115	JSVMClientData* clientData = new JSVMClientData(*vm);
116	vm->clientData = clientData; // ~VM deletes this pointer.	116	vm->clientData = clientData; // ~VM deletes this pointer.
117		117
118	vm->heap.addMarkingConstraint(makeUnique<DOMGCOutputConstraint>(vm, clientData));	118	vm->heap.addMarkingConstraint(makeUnique<DOMGCOutputConstraint>(vm, clientData));
119		119
120	clientData->m_normalWorld = DOMWrapperWorld::create(*vm, true);	120	clientData->m_normalWorld = DOMWrapperWorld::create(*vm, DOMWrapperWorld::Type::Normal);
121	vm->m_typedArrayController = adoptRef(new WebCoreTypedArrayController());	121	vm->m_typedArrayController = adoptRef(new WebCoreTypedArrayController());
122	}	122	}
123		123

Lines 121-137 static Frame* frameForScriptExecutionContext(ScriptExecutionContext& context) a/Source/WebCore/inspector/InspectorInstrumentation.cpp_sec1
- a/Source/WebCore/inspector/InspectorInstrumentation.cpp -6 / +3 lines
121		121
122	void InspectorInstrumentation::didClearWindowObjectInWorldImpl(InstrumentingAgents& instrumentingAgents, Frame& frame, DOMWrapperWorld& world)	122	void InspectorInstrumentation::didClearWindowObjectInWorldImpl(InstrumentingAgents& instrumentingAgents, Frame& frame, DOMWrapperWorld& world)
123	{	123	{
124	if (&world != &mainThreadNormalWorld())
125	return;
126
127	if (auto* pageDebuggerAgent = instrumentingAgents.pageDebuggerAgent())	124	if (auto* pageDebuggerAgent = instrumentingAgents.pageDebuggerAgent())
128	pageDebuggerAgent->didClearWindowObjectInWorld(frame);	125	pageDebuggerAgent->didClearWindowObjectInWorld(frame, world);
129		126
130	if (auto* pageRuntimeAgent = instrumentingAgents.pageRuntimeAgent())	127	if (auto* pageRuntimeAgent = instrumentingAgents.pageRuntimeAgent())
131	pageRuntimeAgent->didClearWindowObjectInWorld(frame);	128	pageRuntimeAgent->didClearWindowObjectInWorld(frame, world);
132		129
133	if (auto* pageAgent = instrumentingAgents.inspectorPageAgent())	130	if (auto* pageAgent = instrumentingAgents.inspectorPageAgent())
134	pageAgent->didClearWindowObjectInWorld(frame);	131	pageAgent->didClearWindowObjectInWorld(frame, world);
135	}	132	}
136		133
137	bool InspectorInstrumentation::isDebuggerPausedImpl(InstrumentingAgents& instrumentingAgents)	134	bool InspectorInstrumentation::isDebuggerPausedImpl(InstrumentingAgents& instrumentingAgents)

Lines 33-38 a/Source/WebCore/inspector/agents/page/PageDebuggerAgent.cpp_sec1
- a/Source/WebCore/inspector/agents/page/PageDebuggerAgent.cpp -2 / +3 lines
33	#include "PageDebuggerAgent.h"	33	#include "PageDebuggerAgent.h"
34		34
35	#include "CachedResource.h"	35	#include "CachedResource.h"
		36	#include "DOMWrapperWorld.h"
36	#include "Document.h"	37	#include "Document.h"
37	#include "Frame.h"	38	#include "Frame.h"
38	#include "InspectorPageAgent.h"	39	#include "InspectorPageAgent.h"
Lines 139-147 InjectedScript PageDebuggerAgent::injectedScriptForEval(ErrorString& errorString a/Source/WebCore/inspector/agents/page/PageDebuggerAgent.cpp_sec2
139	return injectedScript;	140	return injectedScript;
140	}	141	}
141		142
142	void PageDebuggerAgent::didClearWindowObjectInWorld(Frame& frame)	143	void PageDebuggerAgent::didClearWindowObjectInWorld(Frame& frame, DOMWrapperWorld& world)
143	{	144	{
144	if (!frame.isMainFrame())	145	if (!frame.isMainFrame() \|\| &world != &mainThreadNormalWorld())
145	return;	146	return;
146		147
147	didClearGlobalObject();	148	didClearGlobalObject();

Lines 32-37 a/Source/WebCore/inspector/agents/page/PageRuntimeAgent.cpp_sec1
- a/Source/WebCore/inspector/agents/page/PageRuntimeAgent.cpp -27 / +40 lines
32	#include "config.h"	32	#include "config.h"
33	#include "PageRuntimeAgent.h"	33	#include "PageRuntimeAgent.h"
34		34
		35	#include "DOMWrapperWorld.h"
35	#include "Document.h"	36	#include "Document.h"
36	#include "Frame.h"	37	#include "Frame.h"
37	#include "InspectorPageAgent.h"	38	#include "InspectorPageAgent.h"
Lines 46-53 a/Source/WebCore/inspector/agents/page/PageRuntimeAgent.cpp_sec2
46	#include <JavaScriptCore/InjectedScript.h>	47	#include <JavaScriptCore/InjectedScript.h>
47	#include <JavaScriptCore/InjectedScriptManager.h>	48	#include <JavaScriptCore/InjectedScriptManager.h>
48		49
49	using Inspector::Protocol::Runtime::ExecutionContextDescription;
50
51	namespace WebCore {	50	namespace WebCore {
52		51
53	using namespace Inspector;	52	using namespace Inspector;
Lines 97-111 void PageRuntimeAgent::frameNavigated(Frame& frame) a/Source/WebCore/inspector/agents/page/PageRuntimeAgent.cpp_sec3
97	mainWorldExecState(&frame);	96	mainWorldExecState(&frame);
98	}	97	}
99		98
100	void PageRuntimeAgent::didClearWindowObjectInWorld(Frame& frame)	99	void PageRuntimeAgent::didClearWindowObjectInWorld(Frame& frame, DOMWrapperWorld& world)
101	{	100	{
102	auto* pageAgent = m_instrumentingAgents.inspectorPageAgent();	101	auto* pageAgent = m_instrumentingAgents.inspectorPageAgent();
103	if (!pageAgent)	102	if (!pageAgent)
104	return;	103	return;
105		104
106	auto frameId = pageAgent->frameId(&frame);	105	notifyContextCreated(pageAgent->frameId(&frame), frame.script().globalObject(world), world);
107	auto* scriptState = mainWorldExecState(&frame);
108	notifyContextCreated(frameId, scriptState, nullptr, true);
109	}	106	}
110		107
111	InjectedScript PageRuntimeAgent::injectedScriptForEval(ErrorString& errorString, const int* executionContextId)	108	InjectedScript PageRuntimeAgent::injectedScriptForEval(ErrorString& errorString, const int* executionContextId)
Lines 140-178 void PageRuntimeAgent::reportExecutionContextCreation() a/Source/WebCore/inspector/agents/page/PageRuntimeAgent.cpp_sec4
140	if (!pageAgent)	137	if (!pageAgent)
141	return;	138	return;
142		139
143	Vector<std::pair<JSC::JSGlobalObject, SecurityOrigin>> isolatedContexts;	140	for (auto* frame = &m_inspectedPage.mainFrame(); frame; frame = frame->tree().traverseNext()) {
144	for (Frame* frame = &m_inspectedPage.mainFrame(); frame; frame = frame->tree().traverseNext()) {
145	if (!frame->script().canExecuteScripts(NotAboutToExecuteScript))	141	if (!frame->script().canExecuteScripts(NotAboutToExecuteScript))
146	continue;	142	continue;
147		143
148	String frameId = pageAgent->frameId(frame);	144	auto frameId = pageAgent->frameId(frame);
149		145
150	JSC::JSGlobalObject* scriptState = mainWorldExecState(frame);	146	// Always send the main world first.
151	notifyContextCreated(frameId, scriptState, nullptr, true);	147	auto* mainGlobalObject = mainWorldExecState(frame);
152	frame->script().collectIsolatedContexts(isolatedContexts);	148	notifyContextCreated(frameId, mainGlobalObject, mainThreadNormalWorld());
153	if (isolatedContexts.isEmpty())	149
154	continue;	150	for (auto& jsWindowProxy : frame->windowProxy().jsWindowProxiesAsVector()) {
155	for (auto& [globalObject, securityOrigin] : isolatedContexts) {	151	auto* globalObject = jsWindowProxy->window();
156	if (globalObject != scriptState)	152	if (globalObject == mainGlobalObject)
157	notifyContextCreated(frameId, globalObject, securityOrigin, false);	153	continue;
		154
		155	auto& securityOrigin = downcast<DOMWindow>(jsWindowProxy->wrapped()).document()->securityOrigin();
		156	notifyContextCreated(frameId, globalObject, jsWindowProxy->world(), &securityOrigin);
158	}	157	}
159	isolatedContexts.clear();
160	}	158	}
161	}	159	}
162		160
163	void PageRuntimeAgent::notifyContextCreated(const String& frameId, JSC::JSGlobalObject* scriptState, SecurityOrigin* securityOrigin, bool isPageContext)	161	static Inspector::Protocol::Runtime::ExecutionContextType toProtocol(DOMWrapperWorld::Type type)
164	{	162	{
165	ASSERT(securityOrigin \|\| isPageContext);	163	switch (type) {
		164	case DOMWrapperWorld::Type::Normal:
		165	return Inspector::Protocol::Runtime::ExecutionContextType::Normal;
		166	case DOMWrapperWorld::Type::User:
		167	return Inspector::Protocol::Runtime::ExecutionContextType::User;
		168	case DOMWrapperWorld::Type::Internal:
		169	return Inspector::Protocol::Runtime::ExecutionContextType::Internal;
		170	}
166		171
167	InjectedScript result = injectedScriptManager().injectedScriptFor(scriptState);	172	ASSERT_NOT_REACHED();
168	if (result.hasNoValue())	173	return Inspector::Protocol::Runtime::ExecutionContextType::Internal;
		174	}
		175
		176	void PageRuntimeAgent::notifyContextCreated(const String& frameId, JSC::JSGlobalObject* globalObject, const DOMWrapperWorld& world, SecurityOrigin* securityOrigin)
		177	{
		178	auto injectedScript = injectedScriptManager().injectedScriptFor(globalObject);
		179	if (injectedScript.hasNoValue())
169	return;	180	return;
170		181
171	int executionContextId = injectedScriptManager().injectedScriptIdFor(scriptState);	182	auto name = world.name();
172	String name = securityOrigin ? securityOrigin->toRawString() : String();	183	if (name.isEmpty() && securityOrigin)
173	m_frontendDispatcher->executionContextCreated(ExecutionContextDescription::create()	184	name = securityOrigin->toRawString();
174	.setId(executionContextId)	185
175	.setIsPageContext(isPageContext)	186	m_frontendDispatcher->executionContextCreated(Inspector::Protocol::Runtime::ExecutionContextDescription::create()
		187	.setId(injectedScriptManager().injectedScriptIdFor(globalObject))
		188	.setType(toProtocol(world.type()))
176	.setName(name)	189	.setName(name)
177	.setFrameId(frameId)	190	.setFrameId(frameId)
178	.release());	191	.release());

Lines 158-166 localizedStrings["Audit Warning: %s"] = "Audit Warning: %s"; a/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js_sec1
- a/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js -3 / +2 lines
158	localizedStrings["Audit version: %s"] = "Audit version: %s";	158	localizedStrings["Audit version: %s"] = "Audit version: %s";
159	localizedStrings["Audits"] = "Audits";	159	localizedStrings["Audits"] = "Audits";
160	localizedStrings["Author Style Sheet"] = "Author Style Sheet";	160	localizedStrings["Author Style Sheet"] = "Author Style Sheet";
161	localizedStrings["Auto"] = "Auto";
162	localizedStrings["Auto - %s"] = "Auto - %s";
163	localizedStrings["Auto Increment"] = "Auto Increment";	161	localizedStrings["Auto Increment"] = "Auto Increment";
		162	localizedStrings["Auto \u2014 %s"] = "Auto \u2014 %s";
164	localizedStrings["Auto-expand"] = "Auto-expand";	163	localizedStrings["Auto-expand"] = "Auto-expand";
165	localizedStrings["Automatically continue after evaluating"] = "Automatically continue after evaluating";	164	localizedStrings["Automatically continue after evaluating"] = "Automatically continue after evaluating";
166	localizedStrings["Available Style Sheets"] = "Available Style Sheets";	165	localizedStrings["Available Style Sheets"] = "Available Style Sheets";
Lines 1312-1319 localizedStrings["With Object Properties"] = "With Object Properties"; a/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js_sec2
1312	localizedStrings["Worker"] = "Worker";	1311	localizedStrings["Worker"] = "Worker";
1313	localizedStrings["Worker Thread"] = "Worker Thread";	1312	localizedStrings["Worker Thread"] = "Worker Thread";
1314	localizedStrings["Worker Threads"] = "Worker Threads";	1313	localizedStrings["Worker Threads"] = "Worker Threads";
1315	localizedStrings["Worker \u2014 %s"] = "Worker \u2014 %s";
1316	localizedStrings["Worker: %s"] = "Worker: %s";	1314	localizedStrings["Worker: %s"] = "Worker: %s";
		1315	localizedStrings["Workers"] = "Workers";
1317	localizedStrings["Wrap lines to editor width"] = "Wrap lines to editor width";	1316	localizedStrings["Wrap lines to editor width"] = "Wrap lines to editor width";
1318	localizedStrings["XBM"] = "XBM";	1317	localizedStrings["XBM"] = "XBM";
1319	localizedStrings["XHR"] = "XHR";	1318	localizedStrings["XHR"] = "XHR";

Lines 38-45 WI.RuntimeManager = class RuntimeManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js_sec1
- a/Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js -11 lines
38	target.RuntimeAgent.setSavedResultAlias(WI.settings.consoleSavedResultAlias.value);	38	target.RuntimeAgent.setSavedResultAlias(WI.settings.consoleSavedResultAlias.value);
39	}	39	}
40	});	40	});
41
42	WI.Frame.addEventListener(WI.Frame.Event.ExecutionContextsCleared, this._frameExecutionContextsCleared, this);
43	}	41	}
44		42
45	// Static	43	// Static
Lines 189-203 WI.RuntimeManager = class RuntimeManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js_sec2
189		187
190	// Private	188	// Private
191		189
192	_frameExecutionContextsCleared(event)
193	{
194	let contexts = event.data.contexts \|\| [];
195
196	let currentContextWasDestroyed = contexts.some((context) => context.id === this._activeExecutionContext.id);
197	if (currentContextWasDestroyed)
198	this.activeExecutionContext = WI.mainTarget.executionContext;
199	}
200
201	_tryApplyAwaitConvenience(originalExpression)	190	_tryApplyAwaitConvenience(originalExpression)
202	{	191	{
203	let esprimaSyntaxTree;	192	let esprimaSyntaxTree;

Lines 767-773 a/Source/WebInspectorUI/UserInterface/Main.html_sec1
- a/Source/WebInspectorUI/UserInterface/Main.html -1 / +1 lines
767	<script src="Views/ProfileView.js"></script>	767	<script src="Views/ProfileView.js"></script>
768	<script src="Views/ProgressView.js"></script>	768	<script src="Views/ProgressView.js"></script>
769	<script src="Views/QuickConsole.js"></script>	769	<script src="Views/QuickConsole.js"></script>
770	<script src="Views/QuickConsoleNavigationBar.js"></script>
771	<script src="Views/RadioButtonNavigationItem.js"></script>	770	<script src="Views/RadioButtonNavigationItem.js"></script>
772	<script src="Views/RangeChart.js"></script>	771	<script src="Views/RangeChart.js"></script>
773	<script src="Views/RecordingActionTreeElement.js"></script>	772	<script src="Views/RecordingActionTreeElement.js"></script>
Lines 807-812 a/Source/WebInspectorUI/UserInterface/Main.html_sec2
807	<script src="Views/ShaderProgramContentView.js"></script>	806	<script src="Views/ShaderProgramContentView.js"></script>
808	<script src="Views/ShaderProgramTreeElement.js"></script>	807	<script src="Views/ShaderProgramTreeElement.js"></script>
809	<script src="Views/Sidebar.js"></script>	808	<script src="Views/Sidebar.js"></script>
		809	<script src="Views/SizesToFitNavigationBar.js"></script>
810	<script src="Views/Slider.js"></script>	810	<script src="Views/Slider.js"></script>
811	<script src="Views/SoftContextMenu.js"></script>	811	<script src="Views/SoftContextMenu.js"></script>
812	<script src="Views/SourceCodeTextEditor.js"></script>	812	<script src="Views/SourceCodeTextEditor.js"></script>

Lines 25-48 a/Source/WebInspectorUI/UserInterface/Models/ExecutionContext.js_sec1
- a/Source/WebInspectorUI/UserInterface/Models/ExecutionContext.js -5 / +34 lines
25		25
26	WI.ExecutionContext = class ExecutionContext	26	WI.ExecutionContext = class ExecutionContext
27	{	27	{
28	constructor(target, id, name, isPageContext, frame)	28	constructor(target, id, type, name, frame)
29	{	29	{
30	console.assert(target instanceof WI.Target);	30	console.assert(target instanceof WI.Target);
31	console.assert(typeof id === "number" \|\| id === WI.RuntimeManager.TopLevelExecutionContextIdentifier);	31	console.assert(typeof id === "number" \|\| id === WI.RuntimeManager.TopLevelExecutionContextIdentifier);
32	console.assert(typeof name === "string");	32	console.assert(Object.values(WI.ExecutionContext.Type).includes(type));
		33	console.assert(!name \|\| typeof name === "string");
		34	console.assert(frame instanceof WI.Frame \|\| id === WI.RuntimeManager.TopLevelExecutionContextIdentifier);
33		35
34	this._target = target;	36	this._target = target;
35	this._id = id;	37	this._id = id;
36	this._name = name;	38	this._type = type \|\| WI.ExecutionContext.Type.Internal;
37	this._isPageContext = isPageContext \|\| false;	39	this._name = name \|\| "";
38	this._frame = frame \|\| null;	40	this._frame = frame \|\| null;
39	}	41	}
40		42
		43	// Static
		44
		45	static typeFromPayload(payload)
		46	{
		47	// COMPATIBILITY (iOS 13.1): `Runtime.ExecutionContextType` did not exist yet.
		48	if (!("type" in payload))
		49	return payload.isPageContext ? WI.ExecutionContext.Type.Normal : WI.ExecutionContext.Type.Internal;
		50
		51	switch (payload.type) {
		52	case InspectorBackend.Enum.Runtime.ExecutionContextType.Normal:
		53	return WI.ExecutionContext.Type.Normal;
		54	case InspectorBackend.Enum.Runtime.ExecutionContextType.User:
		55	return WI.ExecutionContext.Type.User;
		56	case InspectorBackend.Enum.Runtime.ExecutionContextType.Internal:
		57	return WI.ExecutionContext.Type.Internal;
		58	}
		59
		60	console.assert(false, "Unknown Runtime.ExecutionContextType", payload.type);
		61	return WI.ExecutionContext.Type.Internal;
		62	}
		63
41	// Public	64	// Public
42		65
43	get target() { return this._target; }	66	get target() { return this._target; }
44	get id() { return this._id; }	67	get id() { return this._id; }
		68	get type() { return this._type; }
45	get name() { return this._name; }	69	get name() { return this._name; }
46	get isPageContext() { return this._isPageContext; }
47	get frame() { return this._frame; }	70	get frame() { return this._frame; }
48	};	71	};
		72
		73	WI.ExecutionContext.Type = {
		74	Normal: "normal",
		75	User: "user",
		76	Internal: "internal",
		77	};

Lines 47-66 WI.ExecutionContextList = class ExecutionContextList a/Source/WebInspectorUI/UserInterface/Models/ExecutionContextList.js_sec1
- a/Source/WebInspectorUI/UserInterface/Models/ExecutionContextList.js -6 / +3 lines
47	{	47	{
48	// COMPATIBILITY (iOS 13.0): Older iOS releases will send duplicates.	48	// COMPATIBILITY (iOS 13.0): Older iOS releases will send duplicates.
49	// Newer releases will not and this check should be removed eventually.	49	// Newer releases will not and this check should be removed eventually.
50	if (context.isPageContext && this._pageExecutionContext) {	50	if (context.type === WI.ExecutionContext.Type.Normal && this._pageExecutionContext) {
51	console.assert(context.id === this._pageExecutionContext.id);	51	console.assert(context.id === this._pageExecutionContext.id);
52	return false;	52	return;
53	}	53	}
54		54
55	this._contexts.push(context);	55	this._contexts.push(context);
56		56
57	if (context.isPageContext) {	57	if (context.type === WI.ExecutionContext.Type.Normal && context.target.type === WI.TargetType.Page) {
58	console.assert(!this._pageExecutionContext);	58	console.assert(!this._pageExecutionContext);
59	this._pageExecutionContext = context;	59	this._pageExecutionContext = context;
60	return true;
61	}	60	}
62
63	return false;
64	}	61	}
65		62
66	clear()	63	clear()

Lines 29-36 WI.WorkerTarget = class WorkerTarget extends WI.Target a/Source/WebInspectorUI/UserInterface/Protocol/WorkerTarget.js_sec1
- a/Source/WebInspectorUI/UserInterface/Protocol/WorkerTarget.js -2 / +1 lines
29	{	29	{
30	super(parentTarget, workerId, name, WI.TargetType.Worker, connection, options);	30	super(parentTarget, workerId, name, WI.TargetType.Worker, connection, options);
31		31
32	const isPageContext = false;	32	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, WI.ExecutionContext.Type.Normal, this.displayName);
33	this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, this.displayName, isPageContext, null);
34	}	33	}
35		34
36	// Protected (Target)	35	// Protected (Target)

Lines 120-125 InspectorProtocol.addEventListener = function(eventTypeOrObject, listener) a/Source/WebInspectorUI/UserInterface/Test/InspectorProtocol.js_sec1
- a/Source/WebInspectorUI/UserInterface/Test/InspectorProtocol.js +21 lines
120	throw new Error("Cannot register the same listener more than once.");	120	throw new Error("Cannot register the same listener more than once.");
121		121
122	listeners.push(listener);	122	listeners.push(listener);
		123	return listener;
		124	};
		125
		126	InspectorProtocol.removeEventListener = function(eventTypeOrObject, listener)
		127	{
		128	let event = eventTypeOrObject;
		129	if (typeof eventTypeOrObject === "object")
		130	({event, listener} = eventTypeOrObject);
		131
		132	if (typeof event !== "string")
		133	throw new Error("Event name must be a string.");
		134
		135	if (typeof listener !== "function")
		136	throw new Error("Event listener must be callable.");
		137
		138	// Convert to an array of listeners.
		139	let listeners = InspectorProtocol.eventHandler[event];
		140	if (!listeners)
		141	return;
		142
		143	listeners.removeAll(listener);
123	};	144	};
124		145
125	InspectorProtocol.checkForError = function(responseObject)	146	InspectorProtocol.checkForError = function(responseObject)

Lines 51-57 a/Source/WebInspectorUI/UserInterface/Views/QuickConsole.css_sec1
- a/Source/WebInspectorUI/UserInterface/Views/QuickConsole.css -20 / +24 lines
51		51
52	align-items: flex-start;	52	align-items: flex-start;
53		53
54	max-height: 150px;	54	max-height: 33vh;
55		55
56	overflow-y: auto;	56	overflow-y: auto;
57	overflow-x: hidden;	57	overflow-x: hidden;
Lines 79-113 a/Source/WebInspectorUI/UserInterface/Views/QuickConsole.css_sec2
79	}	79	}
80		80
81	.quick-console > .navigation-bar {	81	.quick-console > .navigation-bar {
82	background: transparent;
83	border: none;
84
85	height: 21px;	82	height: 21px;
		83	border-bottom: none;
86	}	84	}
87		85
88	.quick-console .execution-context {	86	.quick-console > .navigation-bar .active-execution-context {
89	margin-top: -1px;
90	}
91
92	.quick-console > .navigation-bar > .hierarchical-path .execution-context {
93	-webkit-margin-end: 7px;	87	-webkit-margin-end: 7px;
94	}
95
96	.quick-console > .navigation-bar > .hierarchical-path .execution-context .separator {
97	display: none;
98	}
99
100	.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) {
101	-webkit-padding-start: 5px;	88	-webkit-padding-start: 5px;
		89	-webkit-padding-end: 1px;
		90	font-family: -webkit-system-font, sans-serif;
		91	font-size: 11px;
102	}	92	}
103		93
104	.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context {	94	.quick-console > .navigation-bar .active-execution-context > .selector-arrows {
105	background: var(--selected-background-color);	95	width: 5px;
106	border-radius: 3px;	96	height: 16px;
		97	margin-top: 2px;
		98	margin-bottom: 2px;
		99	-webkit-margin-start: 4px;
		100	-webkit-margin-end: 3px;
		101	opacity: 0.6;
		102	}
		103
		104	.quick-console > .navigation-bar .active-execution-context:not(.automatic) {
		105	margin-top: -1px;
		106	height: 20px;
		107	-webkit-margin-start: 5px;
		108	line-height: 20px;
107	color: var(--selected-foreground-color);	109	color: var(--selected-foreground-color);
		110	background-color: var(--selected-background-color);
		111	border-radius: 3px;
108	}	112	}
109		113
110	.quick-console > .navigation-bar > .hierarchical-path:not(.automatic-execution-context) .execution-context .selector-arrows {	114	.quick-console > .navigation-bar .active-execution-context:not(.automatic) > .selector-arrows {
111	color: var(--selected-foreground-color);	115	color: var(--selected-foreground-color);
112	opacity: 1;	116	opacity: 1;
113	}	117	}

Lines 1-38 a/Source/WebInspectorUI/UserInterface/Views/QuickConsoleNavigationBar.js_sec1
- a/Source/WebInspectorUI/UserInterface/Views/QuickConsoleNavigationBar.js -38 lines
1	/*
2	* Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	WI.QuickConsoleNavigationBar = class QuickConsoleNavigationBar extends WI.NavigationBar
27	{
28	get sizesToFit()
29	{
30	return true;
31	}
32
33	addNavigationItem(navigationItem)
34	{
35	// Add new navigation items to the left.
36	return this.insertNavigationItem(navigationItem, 0);
37	}
38	};

Line 0 a/Source/WebInspectorUI/UserInterface/Views/SizesToFitNavigationBar.js_sec1
- a/Source/WebInspectorUI/UserInterface/Views/SizesToFitNavigationBar.js +32 lines
	1	/*
	2	* Copyright (C) 2020 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	23	* THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	WI.SizesToFitNavigationBar = class SizesToFitNavigationBar extends WI.NavigationBar
	27	{
	28	get sizesToFit()
	29	{
	30	return true;
	31	}
	32	};

Lines 50-63 static String uniqueWorldName() a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundleScriptWorld.cpp_sec1
- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundleScriptWorld.cpp -4 / +4 lines
50	return makeString("UniqueWorld_", uniqueWorldNameNumber++);	50	return makeString("UniqueWorld_", uniqueWorldNameNumber++);
51	}	51	}
52		52
53	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create()	53	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create(Type type)
54	{	54	{
55	return adoptRef(*new InjectedBundleScriptWorld(ScriptController::createWorld(), uniqueWorldName()));	55	return InjectedBundleScriptWorld::create(uniqueWorldName(), type);
56	}	56	}
57		57
58	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create(const String& name)	58	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::create(const String& name, Type type)
59	{	59	{
60	return adoptRef(*new InjectedBundleScriptWorld(ScriptController::createWorld(), name));	60	return adoptRef(*new InjectedBundleScriptWorld(ScriptController::createWorld(name, type == Type::User ? ScriptController::WorldType::User : ScriptController::WorldType::Internal), name));
61	}	61	}
62		62
63	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::getOrCreate(DOMWrapperWorld& world)	63	Ref<InjectedBundleScriptWorld> InjectedBundleScriptWorld::getOrCreate(DOMWrapperWorld& world)

Lines 39-46 namespace WebKit { a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundleScriptWorld.h_sec1
- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundleScriptWorld.h -2 / +3 lines
39		39
40	class InjectedBundleScriptWorld : public API::ObjectImpl<API::Object::Type::BundleScriptWorld> {	40	class InjectedBundleScriptWorld : public API::ObjectImpl<API::Object::Type::BundleScriptWorld> {
41	public:	41	public:
42	static Ref<InjectedBundleScriptWorld> create();	42	enum class Type { User, Internal };
43	static Ref<InjectedBundleScriptWorld> create(const String&);	43	static Ref<InjectedBundleScriptWorld> create(Type = Type::Internal);
		44	static Ref<InjectedBundleScriptWorld> create(const String& name, Type = Type::Internal);
44	static Ref<InjectedBundleScriptWorld> getOrCreate(WebCore::DOMWrapperWorld&);	45	static Ref<InjectedBundleScriptWorld> getOrCreate(WebCore::DOMWrapperWorld&);
45	static InjectedBundleScriptWorld* find(const String&);	46	static InjectedBundleScriptWorld* find(const String&);
46	static InjectedBundleScriptWorld& normalWorld();	47	static InjectedBundleScriptWorld& normalWorld();

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +22 lines
		1	2020-02-27 Devin Rousso <drousso@apple.com>
		2
		3	Web Inspector: unable to evaluate in the isolated world of content scripts injected by safari app extensions
		4	https://bugs.webkit.org/show_bug.cgi?id=206110
		5	<rdar://problem/16945643>
		6
		7	Reviewed by Timothy Hatcher, Joseph Pecoraro, and Brian Burg.
		8
		9	In addition to evaluating in subframe execution contexts, add the ability for Web Inspector
		10	to evaluate in non-normal isolated worlds.
		11
		12	* inspector/runtime/executionContextCreated-isolated-world.html: Added.
		13	* inspector/runtime/executionContextCreated-isolated-world-expected.txt: Added.
		14
		15	* inspector/runtime/change-execution-context-identifier.html:
		16	* inspector/runtime/change-execution-context-identifier-expected.txt:
		17	Don't expect the active execution context to change when the owner frame is removed, as that
		18	is now handled by the UI (`WI.QuickConsole`) instead of the `WI.RuntimeManager`.
		19
		20	* inspector/runtime/executionContextCreated-onEnable.html:
		21	Ignore internal worlds.
		22
1	2020-01-26 Said Abou-Hallawa <said@apple.com>	23	2020-01-26 Said Abou-Hallawa <said@apple.com>
2		24
3	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler	25	Throttling requestAnimationFrame should be controlled by RenderingUpdateScheduler

Lines 85-90 function test() a/LayoutTests/inspector/runtime/change-execution-context-identifier.html_sec1
- a/LayoutTests/inspector/runtime/change-execution-context-identifier.html -1 / +2 lines
85		85
86	// Set the execution context to the subframe so we can switch away from it when the frame is detached.	86	// Set the execution context to the subframe so we can switch away from it when the frame is detached.
87	WI.runtimeManager.activeExecutionContext = subframes[0].pageExecutionContext;	87	WI.runtimeManager.activeExecutionContext = subframes[0].pageExecutionContext;
		88	let activeExecutionContextId = WI.runtimeManager.activeExecutionContext.id;
88		89
89	// Force-override the contextId, otherwise we won't be able to access the iframe's DOM element when evaluating in the iframe execution context.	90	// Force-override the contextId, otherwise we won't be able to access the iframe's DOM element when evaluating in the iframe execution context.
90	let expression = `document.getElementById("subframe").remove();`;	91	let expression = `document.getElementById("subframe").remove();`;
Lines 92-98 function test() a/LayoutTests/inspector/runtime/change-execution-context-identifier.html_sec2
92	let contextId = WI.RuntimeManager.TopLevelExecutionContextIdentifier;	93	let contextId = WI.RuntimeManager.TopLevelExecutionContextIdentifier;
93	RuntimeAgent.evaluate.invoke({expression, objectGroup, contextId}, () => {	94	RuntimeAgent.evaluate.invoke({expression, objectGroup, contextId}, () => {
94	InspectorTest.expectEqual(WI.networkManager.frames.length, 1, "The test page should now have no sub-frames.");	95	InspectorTest.expectEqual(WI.networkManager.frames.length, 1, "The test page should now have no sub-frames.");
95	InspectorTest.expectEqual(WI.runtimeManager.activeExecutionContext.id, WI.RuntimeManager.TopLevelExecutionContextIdentifier, "When a selected non-top-level execution context is removed, the active execution context should revert to the main frame context.");	96	InspectorTest.expectEqual(WI.runtimeManager.activeExecutionContext.id, activeExecutionContextId, "When a selected non-top-level execution context is removed, the active execution context should not change, as that is handled by the UI.");
96	resolve();	97	resolve();
97	});	98	});
98	}	99	}

Line 0 a/LayoutTests/inspector/runtime/executionContextCreated-isolated-world-expected.txt_sec1
- a/LayoutTests/inspector/runtime/executionContextCreated-isolated-world-expected.txt +9 lines
	1
	2	Test that exactly one Runtime.executionContextCreated event is fired for each existing context when Runtime.enable is called.
	3
	4
	5	== Running test suite: Runtime.executionContextCreated.IsolatedWorld
	6	-- Running test case: Runtime.executionContextCreated.IsolatedWorld.Internal
	7	PASS: Received event for internal isolated world.
	8	PASS: Execution context should be internal.
	9

Line 0 a/LayoutTests/inspector/runtime/executionContextCreated-isolated-world.html_sec1
- a/LayoutTests/inspector/runtime/executionContextCreated-isolated-world.html +63 lines
	1	<html>
	2	<head>
	3	<script src="../../http/tests/inspector/resources/protocol-test.js"></script>
	4	<script src="../../http/tests/inspector/resources/stable-id-map.js"></script>
	5	<script>
	6	function createIsolatedWorld() {
	7	const name = "InspectorTestInternalIsolatedWorld";
	8	function source() { return 42; }
	9
	10	if (window.internals)
	11	window.internals.evaluateInWorldIgnoringException(name, source.toString());
	12	}
	13
	14	function test()
	15	{
	16	ProtocolTest.debug();
	17
	18	let suite = ProtocolTest.createAsyncSuite("Runtime.executionContextCreated.IsolatedWorld");
	19
	20	suite.addTestCase({
	21	name: "Runtime.executionContextCreated.IsolatedWorld.Internal",
	22	description: "Test that Runtime.executionContextCreated events are dispatched for internal isolated worlds.",
	23	async test() {
	24	let completion = new WI.WrappedPromise;
	25
	26	let listener = InspectorProtocol.addEventListener("Runtime.executionContextCreated", (messageObject) => {
	27	let {id, name, type} = messageObject.params.context;
	28	if (name !== "InspectorTestInternalIsolatedWorld")
	29	return;
	30
	31	InspectorProtocol.removeEventListener("Runtime.executionContextCreated", listener);
	32
	33	ProtocolTest.pass("Received event for internal isolated world.");
	34	ProtocolTest.expectEqual(type, "internal", "Execution context should be internal.");
	35
	36	completion.resolve();
	37	});
	38
	39	await Promise.all([
	40	InspectorProtocol.awaitCommand({method: "Page.enable"}),
	41	InspectorProtocol.awaitCommand({method: "Runtime.enable"}),
	42	]);
	43
	44	await InspectorProtocol.awaitCommand({
	45	method: "Runtime.evaluate",
	46	params: {
	47	expression: `createIsolatedWorld()`,
	48	},
	49	});
	50
	51	await completion.promise;
	52	},
	53	});
	54
	55	suite.runTestCasesAndFinish();
	56	}
	57	</script>
	58	</head>
	59	<body>
	60	<iframe id="subframe" src="resources/change-execution-context-identifier-subframe.html" onload="runTest()"></iframe>
	61	<p>Test that exactly one Runtime.executionContextCreated event is fired for each existing context when Runtime.enable is called.</p>
	62	</body>
	63	</html>