ChangeLog

112016-06-27 Brian Burg <bburg@apple.com>

        Web Inspector: QuickConsole should update its selection when RuntimeManager.defaultExecutionContextIdentifier changes

        https://bugs.webkit.org/show_bug.cgi?id=159183

        Reviewed by NOBODY (OOPS!).

        Currently, the UI listens for state changes in the Frame tree to decide when to reset

        the selected execution context back to its default value. This is no good, because this

        should happen even if we have no UI (i.e., testing models only). The UI should simply

        display changes to the model rather than driving them based on other model changes.

        Move the logic to reset the execution context into RuntimeManager. When the selected

        context changes, an event is fired which causes the QuickConsole to rebuild its path components.

        * UserInterface/Controllers/RuntimeManager.js:

        (WebInspector.RuntimeManager):

        (WebInspector.RuntimeManager.prototype.set defaultExecutionContextIdentifier):

        Fire an event when the execution context actually changes.

        (WebInspector.RuntimeManager.prototype._frameExecutionContextsCleared):

        Added. If the selected context was cleared, reset back to default.

        * UserInterface/Models/Frame.js:

        (WebInspector.Frame.prototype.clearExecutionContexts):

        Include the contexts that were cleared so clients can match against them.

        * UserInterface/Views/QuickConsole.js:

        (WebInspector.QuickConsole):

        Use the proper constant name. Both the old and new names evaluated to `undefined`.

        No need to keep track of the selected path component, it will always match the

        defaultExecutionContextIdentifier in RuntimeManager.

        (WebInspector.QuickConsole.prototype.get selectedExecutionContextIdentifier):

        (WebInspector.QuickConsole.prototype.set selectedExecutionContextIdentifier):

        Forward to RuntimeManager. This name is less awkward for the UI code that manages selections.

        (WebInspector.QuickConsole.prototype._executionContextPathComponentsToDisplay):

        Special-case for the main frame execution context.

        (WebInspector.QuickConsole.prototype._framePageExecutionContextsChanged):

        Remove indirection.

        (WebInspector.QuickConsole.prototype._frameExecutionContextsCleared):

        Fix the guard to handle undefined execution contexts in the case where it represents the main frame (undefined).

        (WebInspector.QuickConsole.prototype._defaultExecutionContextChanged):

        Rebuild when the model changes.

        (WebInspector.QuickConsole.prototype._pathComponentSelected): Simplify.

        (WebInspector.QuickConsole.prototype.get executionContextIdentifier):

        (WebInspector.QuickConsole.prototype._removeExecutionContextPathComponentForFrame):

        Move the fallback selection behavior into RuntimeManager.

        (WebInspector.QuickConsole.prototype._updateExecutionContextPathComponentForFrame): Deleted.

        This has been dead code ever since we removed iOS 6 legacy support.

2016-06-27  Brian Burg  <bburg@apple.com>

        Web Inspector: RuntimeManager should not use view object WebInspector.quickConsole

        https://bugs.webkit.org/show_bug.cgi?id=128092

        <rdar://problem/15966526>

Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js

@@WebInspector.RuntimeManager = class RuntimeManager extends WebInspector.Object

        // Enable the RuntimeAgent to receive notification of execution contexts.

        RuntimeAgent.enable();

35 WebInspector.Frame.addEventListener(WebInspector.Frame.Event.ExecutionContextsCleared, this._frameExecutionContextsCleared, this);

    }

    // Public

@@WebInspector.RuntimeManager = class RuntimeManager extends WebInspector.Object

    }

    get defaultExecutionContextIdentifier() { return this._defaultExecutionContextIdentifier; }

127 set defaultExecutionContextIdentifier(value) { this._defaultExecutionContextIdentifier = value; }

    set defaultExecutionContextIdentifier(value)

    {

        if (this._defaultExecutionContextIdentifier === value)

            return;

        this._defaultExecutionContextIdentifier = value;

        this.dispatchEventToListeners(WebInspector.RuntimeManager.Event.DefaultExecutionContextChanged);

    }

    // Private

    _frameExecutionContextsCleared(event)

    {

        let contexts = event.data.contexts || [];

        let currentContextWasDestroyed = contexts.some((context) => context.id === this._defaultExecutionContextIdentifier);

        if (currentContextWasDestroyed)

            this.defaultExecutionContextIdentifier = WebInspector.RuntimeManager.TopLevelExecutionContextIdentifier;

    }

};

WebInspector.RuntimeManager.TopLevelExecutionContextIdentifier = undefined;

WebInspector.RuntimeManager.Event = {

133 DidEvaluate: "runtime-manager-did-evaluate"

153 DidEvaluate: Symbol("runtime-manager-did-evaluate"),

154 DefaultExecutionContextChanged: Symbol("runtime-manager-default-execution-context-changed"),

};

WebInspector.RuntimeManager.ConsoleObjectGroup = "console";

Source/WebInspectorUI/UserInterface/Models/Frame.js

@@WebInspector.Frame = class Frame extends WebInspector.Object

    clearExecutionContexts(committingProvisionalLoad)

    {

        if (this._executionContextList.contexts.length) {

209 let contexts = this._executionContextList.contexts.slice();

209210 this._executionContextList.clear();

210 this.dispatchEventToListeners(WebInspector.Frame.Event.ExecutionContextsCleared, {committingProvisionalLoad:!!committingProvisionalLoad});

211 this.dispatchEventToListeners(WebInspector.Frame.Event.ExecutionContextsCleared, {committingProvisionalLoad:!!committingProvisionalLoad, contexts});

        }

    }

Source/WebInspectorUI/UserInterface/Views/QuickConsole.js

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        this._toggleOrFocusKeyboardShortcut = new WebInspector.KeyboardShortcut(null, WebInspector.KeyboardShortcut.Key.Escape, this._toggleOrFocus.bind(this));

34 ~~var~~ mainFrameExecutionContext = new WebInspector.ExecutionContext(WebInspector.Qu~~ickConsol~~e.~~Mai~~nF~~ram~~eContextExecutionIdentifier, WebInspector.UIString("Main Frame"), true, null);

34 let mainFrameExecutionContext = new WebInspector.ExecutionContext(WebInspector.RuntimeManager.TopLevelContextExecutionIdentifier, WebInspector.UIString("Main Frame"), true, null);

3535 this._mainFrameExecutionContextPathComponent = this._createExecutionContextPathComponent(mainFrameExecutionContext.name, mainFrameExecutionContext.identifier);

36 this._selectedExecutionContextPathComponent = this._mainFrameExecutionContextPathComponent;

        this._otherExecutionContextPathComponents = [];

        this._frameIdentifierToExecutionContextPathComponentMap = {};

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        WebInspector.Frame.addEventListener(WebInspector.Frame.Event.ExecutionContextsCleared, this._frameExecutionContextsCleared, this);

        WebInspector.debuggerManager.addEventListener(WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, this._debuggerActiveCallFrameDidChange, this);

73 WebInspector.runtimeManager.addEventListener(WebInspector.RuntimeManager.Event.DefaultExecutionContextChanged, this._defaultExecutionContextChanged, this);

    }

    // Public

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        return this._navigationBar;

    }

82 get executionContextIdentifier()

83 get selectedExecutionContextIdentifier()

8384 {

84 return this._selectedExecutionContextPathComponent._executionContextIdentifier;

        return WebInspector.runtimeManager.defaultExecutionContextIdentifier;

    }

    set selectedExecutionContextIdentifier(value)

    {

        if (value === this.selectedExecutionContextIdentifier)

            return;

        WebInspector.runtimeManager.defaultExecutionContextIdentifier = value;

    }

    consoleLogVisibilityChanged(visible)

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        if (!this._otherExecutionContextPathComponents.length)

            return [];

127 return [this._selectedExecutionContextPathComponent];

        if (this.selectedExecutionContextIdentifier === this._mainFrameExecutionContextPathComponent._executionContextIdentifier)

            return [this._mainFrameExecutionContextPathComponent];

        return this._otherExecutionContextPathComponents.filter((component) => component._executionContextIdentifier === this.selectedExecutionContextIdentifier);

    }

    _rebuildExecutionContextPathComponents()

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        var newExecutionContextPathComponent = this._insertExecutionContextPathComponentForFrame(frame, shouldAutomaticallySelect);

        if (shouldAutomaticallySelect) {

            delete this._restoreSelectedExecutionContextForFrame;

            this._selectedExecutionContextPathComponent = newExecutionContextPathComponent;

            WebInspector.runtimeManager.defaultExecutionContextIdentifier = this.executionContextIdentifier;

            this._rebuildExecutionContextPathComponents();

162 this._restoreSelectedExecutionContextForFrame = null;

163 this.selectedExecutionContextIdentifier = newExecutionContextPathComponent._executionContextIdentifier;

        }

    }

    _frameExecutionContextsCleared(event)

    {

159 ~~var~~ frame = event.target;

169 let frame = event.target;

        // If this frame is navigating and it is selected in the UI we want to reselect its new item after navigation.

        if (event.data.committingProvisionalLoad && !this._restoreSelectedExecutionContextForFrame) {

163 ~~var~~ executionContextPathComponent = this._frameIdentifierToExecutionContextPathComponentMap[frame.id];

164 if (~~this._selectedE~~xecutionContextPathComponent ~~===~~ executionContextPathComponent) {

173 let executionContextPathComponent = this._frameIdentifierToExecutionContextPathComponentMap[frame.id];

174 if (executionContextPathComponent && executionContextPathComponent._executionContextIdentifier === this.selectedExecutionContextIdentifier) {

165175 this._restoreSelectedExecutionContextForFrame = frame;

166176 // As a fail safe, if the frame never gets an execution context, clear the restore value.

167 setTimeout(~~function~~() ~~{ delete~~ this._restoreSelectedExecutionContextForFrame; }~~.bind(this)~~, 10);

177 setTimeout(() => { this._restoreSelectedExecutionContextForFrame = false; }, 10);

            }

        }

        this._removeExecutionContextPathComponentForFrame(frame);

    }

    _defaultExecutionContextChanged(event)

    {

        this._rebuildExecutionContextPathComponents();

    }

    _createExecutionContextPathComponent(name, identifier)

    {

        var pathComponent = new WebInspector.HierarchicalPathComponent(name, "execution-context", identifier, true, true);

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

        if (next)

            next.previousSibling = prev;

        if (this._selectedExecutionContextPathComponent === executionContextPathComponent) {

            this._selectedExecutionContextPathComponent = this._mainFrameExecutionContextPathComponent;

            WebInspector.runtimeManager.defaultExecutionContextIdentifier = this.executionContextIdentifier;

        }

        this._otherExecutionContextPathComponents.remove(executionContextPathComponent, true);

        delete this._frameIdentifierToExecutionContextPathComponentMap[frame.id];

@@WebInspector.QuickConsole = class QuickConsole extends WebInspector.View

            this._rebuildExecutionContextPathComponents();

    }

    _updateExecutionContextPathComponentForFrame(frame)

    {

        if (frame.isMainFrame())

            return;

        var executionContextPathComponent = this._frameIdentifierToExecutionContextPathComponentMap[frame.id];

        if (!executionContextPathComponent)

            return;

        var wasSelected = this._selectedExecutionContextPathComponent === executionContextPathComponent;

        this._removeExecutionContextPathComponentForFrame(frame, true);

        var newExecutionContextPathComponent = this._insertExecutionContextPathComponentForFrame(frame, true);

        if (wasSelected) {

            this._selectedExecutionContextPathComponent = newExecutionContextPathComponent;

            WebInspector.runtimeManager.defaultExecutionContextIdentifier = this.executionContextIdentifier;

        }

        this._rebuildExecutionContextPathComponents();

    }

298286 _pathComponentSelected(event)

299287 {

        if (event.data.pathComponent === this._selectedExecutionContextPathComponent)

            return;

        this._selectedExecutionContextPathComponent = event.data.pathComponent;

        WebInspector.runtimeManager.defaultExecutionContextIdentifier = this.executionContextIdentifier;

        this._rebuildExecutionContextPathComponents();

288 this.selectedExecutionContextIdentifier = event.data.pathComponent._executionContextIdentifier;

    }

    _pathComponentClicked(event)

LayoutTests/ChangeLog

112016-06-27 Brian Burg <bburg@apple.com>

        Web Inspector: QuickConsole should update its selection when RuntimeManager.defaultExecutionContextIdentifier changes

        https://bugs.webkit.org/show_bug.cgi?id=159183

        Reviewed by NOBODY (OOPS!).

        Add a new test case for reverting to the top-level execution context when the selected context is destroyed.

        * inspector/runtime/change-execution-context-identifier-expected.txt:

        * inspector/runtime/change-execution-context-identifier.html:

2016-06-27  Brian Burg  <bburg@apple.com>

        Web Inspector: RuntimeManager should not use view object WebInspector.quickConsole

        https://bugs.webkit.org/show_bug.cgi?id=128092

        <rdar://problem/15966526>

LayoutTests/inspector/runtime/change-execution-context-identifier-expected.txt

Test that RuntimeManager.evaluateInInspectedWindow respects the selected execution context.

@@PASS: The passphrase should match the phrase defined in the subframe.

Passphrase in selected frame: coldwater

PASS: The passphrase should match the phrase defined in the main frame.

-- Running test case: ScriptExecutionContextRemoveSubframe

PASS: The test page should only have one sub-frame.

PASS: The test page should now have no sub-frames.

PASS: When a selected non-top-level execution context is removed, the default execution context should revert to the top-level context.

LayoutTests/inspector/runtime/change-execution-context-identifier.html

@@function test()

        description: "Test that evaluateInInspectedWindow works when defaultExecutionContextIdentifier is a subframe context.",

        test: (resolve, reject) => {

            let mainFrame = WebInspector.frameResourceManager.mainFrame;

39 let subframes = WebInspector.frameResourceManager.frames.filter((frame) => frame != mainFrame);

39 let subframes = WebInspector.frameResourceManager.frames.filter((frame) => frame !== mainFrame);

            InspectorTest.expectThat(subframes.length === 1, "The test page should only have one sub-frame.");

            WebInspector.runtimeManager.defaultExecutionContextIdentifier = subframes[0].pageExecutionContext.id;

@@function test()

        }

    });

    suite.addTestCase({

        name: "ScriptExecutionContextRemoveSubframe",

        description: "Test that evaluateInInspectedWindow works when the defaultExecutionContextIdentifier is destroyed and reverts to the top-level context.",

        test: (resolve, reject) => {

            let mainFrame = WebInspector.frameResourceManager.mainFrame;

            let subframes = WebInspector.frameResourceManager.frames.filter((frame) => frame !== mainFrame);

            InspectorTest.expectThat(subframes.length === 1, "The test page should only have one sub-frame.");

            // Set the execution context to the subframe so we can switch away from it when the frame is detached.

            WebInspector.runtimeManager.defaultExecutionContextIdentifier = subframes[0].pageExecutionContext.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 objectGroup = "test";

            let contextId = WebInspector.RuntimeManager.TopLevelExecutionContextIdentifier;

            RuntimeAgent.evaluate.invoke({expression, objectGroup, contextId}, () => {

                InspectorTest.expectThat(WebInspector.frameResourceManager.frames.length === 1, "The test page should now have no sub-frames.");

                InspectorTest.expectThat(WebInspector.runtimeManager.defaultExecutionContextIdentifier === WebInspector.RuntimeManager.TopLevelExecutionContextIdentifier, "When a selected non-top-level execution context is removed, the default execution context should revert to the top-level context.");

                resolve();

            });

        }

    });

    suite.runTestCasesAndFinish();

}

</script>

</head>

<body>

71 <iframe src="resources/change-execution-context-identifier-subframe.html" onload="runTest()"></iframe>

94<iframe id="subframe" src="resources/change-execution-context-identifier-subframe.html" onload="runTest()"></iframe>

<p>Test that RuntimeManager.evaluateInInspectedWindow respects the selected execution context.</p>

</body>

</html>