Changeset 208246 in webkit


Ignore:
Timestamp:
Nov 1, 2016 2:48:31 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

Web Inspector: Replace sublists inside DOM-related model objects with WI.Collection
https://bugs.webkit.org/show_bug.cgi?id=164098

Patch by Devin Rousso <Devin Rousso> on 2016-11-01
Reviewed by Timothy Hatcher.

Source/WebInspectorUI:

  • UserInterface/Models/DOMTree.js:
  • UserInterface/Models/Frame.js:

Add support for WebInspector.Collection.

  • UserInterface/Models/Script.js:

(WebInspector.Script):

  • UserInterface/Views/DebuggerSidebarPanel.js:

(WebInspector.DebuggerSidebarPanel.prototype._addResourcesRecursivelyForFrame):

  • UserInterface/Views/FrameTreeElement.js:

(WebInspector.FrameTreeElement):
(WebInspector.FrameTreeElement.prototype.onpopulate):

  • UserInterface/Views/OpenResourceDialog.js:

(WebInspector.OpenResourceDialog.prototype._addResourcesForFrame):
Use new functions defined by changing to WebInspector.Collection.

LayoutTests:

  • http/tests/inspector/console/cross-domain-inspected-node-access-expected.txt:
  • http/tests/inspector/console/cross-domain-inspected-node-access.html:
  • http/tests/inspector/dom/disconnect-dom-tree-after-main-frame-navigation.html:
  • inspector/css/manager-preferredInspectorStyleSheetForFrame-expected.txt:
  • inspector/css/manager-preferredInspectorStyleSheetForFrame.html:
  • inspector/dom/content-flow-list.html:
  • inspector/dom/highlightFrame-expected.txt:
  • inspector/dom/highlightFrame.html:
  • inspector/dom/highlightNode-expected.txt:
  • inspector/dom/highlightNode.html:
  • inspector/dom/highlightSelector-expected.txt:
  • inspector/dom/highlightSelector.html:
  • inspector/model/frame-extra-scripts-expected.txt:
  • inspector/model/frame-extra-scripts.html:

Change functionality to support WebInspector.Collection methods.

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r208242 r208246  
     12016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>
     2
     3        Web Inspector: Replace sublists inside DOM-related model objects with WI.Collection
     4        https://bugs.webkit.org/show_bug.cgi?id=164098
     5
     6        Reviewed by Timothy Hatcher.
     7
     8        * http/tests/inspector/console/cross-domain-inspected-node-access-expected.txt:
     9        * http/tests/inspector/console/cross-domain-inspected-node-access.html:
     10        * http/tests/inspector/dom/disconnect-dom-tree-after-main-frame-navigation.html:
     11        * inspector/css/manager-preferredInspectorStyleSheetForFrame-expected.txt:
     12        * inspector/css/manager-preferredInspectorStyleSheetForFrame.html:
     13        * inspector/dom/content-flow-list.html:
     14        * inspector/dom/highlightFrame-expected.txt:
     15        * inspector/dom/highlightFrame.html:
     16        * inspector/dom/highlightNode-expected.txt:
     17        * inspector/dom/highlightNode.html:
     18        * inspector/dom/highlightSelector-expected.txt:
     19        * inspector/dom/highlightSelector.html:
     20        * inspector/model/frame-extra-scripts-expected.txt:
     21        * inspector/model/frame-extra-scripts.html:
     22        Change functionality to support WebInspector.Collection methods.
     23
    1242016-11-01  Antoine Quint  <graouts@apple.com>
    225
  • trunk/LayoutTests/http/tests/inspector/console/cross-domain-inspected-node-access-expected.txt

    r200533 r208246  
    44
    55
     6PASS: Page should have a subframe.
    67
    78== Running test suite: CommandLineAPI.$0.cross-frame
  • trunk/LayoutTests/http/tests/inspector/console/cross-domain-inspected-node-access.html

    r192186 r208246  
    88    let suite = InspectorTest.createAsyncSuite("CommandLineAPI.$0.cross-frame");
    99
     10    let mainFrame = WebInspector.frameResourceManager.mainFrame;
     11    let childFrames = mainFrame.childFrameCollection.toArray();
     12    InspectorTest.expectEqual(childFrames.length, 1, "Page should have a subframe.");
     13
    1014    let nodeInMainFrameId;
    1115    let nodeInSubFrameId;
     
    1418        name: "AttemptCrossFrame$0AccessFromMainFrame",
    1519        description: "Should not be able to access $0 node in different domain subframe from the main frame.",
    16         test: (resolve, reject) => {
     20        test(resolve, reject) {
    1721            InspectorTest.log("Setting $0 to node within subframe.");
    1822            ConsoleAgent.addInspectedNode(nodeInSubFrameId);
     
    3034        name: "AttemptSameFrame$0AccessFromMainFrame",
    3135        description: "Should be able to access $0 node in the same frame.",
    32         test: (resolve, reject) => {
     36        test(resolve, reject) {
    3337            InspectorTest.log("Setting $0 to node within the main frame.");
    3438            ConsoleAgent.addInspectedNode(nodeInMainFrameId);
     
    4650        name: "AttemptCrossFrame$0AccessFromSubFrame",
    4751        description: "Should not be able to access $0 node in different domain main frame from the subframe.",
    48         test: (resolve, reject) => {
     52        test(resolve, reject) {
    4953            InspectorTest.log("Setting $0 to node within the main frame.");
    5054            ConsoleAgent.addInspectedNode(nodeInMainFrameId);
    51             const childFrame = WebInspector.frameResourceManager.mainFrame.childFrames[0];
    52             RuntimeAgent.evaluate.invoke({expression: "$0", includeCommandLineAPI: true, contextId: childFrame.pageExecutionContext.id}, (error, remoteObjectPayload, wasThrown) => {   
     55            RuntimeAgent.evaluate.invoke({expression: "$0", includeCommandLineAPI: true, contextId: childFrames[0].pageExecutionContext.id}, (error, remoteObjectPayload, wasThrown) => {
    5356                InspectorTest.assert(!error, "Should not be a protocol error.");
    5457                InspectorTest.assert(!wasThrown, "Should not be an exception.");
     
    6366        name: "AttemptSameFrame$0AccessFromSubFrame",
    6467        description: "Should be able to access $0 node in the same frame.",
    65         test: (resolve, reject) => {
     68        test(resolve, reject) {
    6669            InspectorTest.log("Setting $0 to node within the subframe.");
    6770            ConsoleAgent.addInspectedNode(nodeInSubFrameId);
    68             const childFrame = WebInspector.frameResourceManager.mainFrame.childFrames[0];
    69             RuntimeAgent.evaluate.invoke({expression: "$0", includeCommandLineAPI: true, contextId: childFrame.pageExecutionContext.id}, (error, remoteObjectPayload, wasThrown) => {
     71            RuntimeAgent.evaluate.invoke({expression: "$0", includeCommandLineAPI: true, contextId: childFrames[0].pageExecutionContext.id}, (error, remoteObjectPayload, wasThrown) => {
    7072                InspectorTest.assert(!error, "Should not be a protocol error.");
    7173                InspectorTest.assert(!wasThrown, "Should not be an exception.");
  • trunk/LayoutTests/http/tests/inspector/dom/disconnect-dom-tree-after-main-frame-navigation.html

    r206130 r208246  
    3131
    3232            // Force creation of child DOM trees.
    33             mainFrame.childFrames[0].domTree;
    34             mainFrame.childFrames[0].childFrames[0].domTree;
    35             mainFrame.childFrames[0].childFrames[0].childFrames[0].domTree;
     33            let childrenLevel1 = mainFrame.childFrameCollection.toArray();
     34            childrenLevel1[0].domTree;
     35
     36            let childrenLevel2 = childrenLevel1[0].childFrameCollection.toArray();
     37            childrenLevel2[0].domTree;
     38
     39            let childrenLevel3 = childrenLevel2[0].childFrameCollection.toArray();
     40            childrenLevel3[0].domTree;
    3641
    3742            instances = WebInspector.domTreeManager.retainedObjectsWithPrototype(WebInspector.DOMTree);
  • trunk/LayoutTests/inspector/css/manager-preferredInspectorStyleSheetForFrame-expected.txt

    r206133 r208246  
    22
    33
     4PASS: Page should have a subframe.
    45
    56== Running test suite: CSSManager.preferredInspectorStyleSheetForFrame
  • trunk/LayoutTests/inspector/css/manager-preferredInspectorStyleSheetForFrame.html

    r206133 r208246  
    77{
    88    let mainFrame = WebInspector.frameResourceManager.mainFrame;
    9     let childFrame = mainFrame.childFrames[0];
     9    let childFrames = mainFrame.childFrameCollection.toArray();
     10    InspectorTest.expectEqual(childFrames.length, 1, "Page should have a subframe.");
    1011
    1112    let suite = InspectorTest.createAsyncSuite("CSSManager.preferredInspectorStyleSheetForFrame");
     
    6566                InspectorTest.expectThat(event.data.styleSheet.origin === WebInspector.CSSStyleSheet.Type.Inspector, "Added StyleSheet origin should be 'inspector'.");
    6667                InspectorTest.expectThat(event.data.styleSheet.isInspectorStyleSheet(), "StyleSheet.isInspectorStyleSheet() should be true.");
    67                 InspectorTest.expectThat(event.data.styleSheet.parentFrame === childFrame, "Added StyleSheet frame should be a child frame.");
     68                InspectorTest.expectThat(event.data.styleSheet.parentFrame === childFrames[0], "Added StyleSheet frame should be a child frame.");
    6869            });
    6970
    70             WebInspector.cssStyleManager.preferredInspectorStyleSheetForFrame(childFrame, (styleSheet) => {
     71            WebInspector.cssStyleManager.preferredInspectorStyleSheetForFrame(childFrames[0], (styleSheet) => {
    7172                InspectorTest.expectThat(WebInspector.cssStyleManager.styleSheets.length === 2, "Should be two stylesheets.");
    7273                InspectorTest.expectThat(styleSheet.origin === WebInspector.CSSStyleSheet.Type.Inspector, "StyleSheet origin should be 'inspector'.");
     
    8485                InspectorTest.assert(false, "Should not create a new StyleSheet, should reuse the existing one");
    8586            });
    86             WebInspector.cssStyleManager.preferredInspectorStyleSheetForFrame(childFrame, (styleSheet) => {
     87            WebInspector.cssStyleManager.preferredInspectorStyleSheetForFrame(childFrames[0], (styleSheet) => {
    8788                InspectorTest.expectThat(WebInspector.cssStyleManager.styleSheets.length === 2, "Should be two stylesheets.");
    8889                InspectorTest.expectThat(styleSheet.origin === WebInspector.CSSStyleSheet.Type.Inspector, "StyleSheet origin should be 'inspector'.");
  • trunk/LayoutTests/inspector/dom/content-flow-list.html

    r188059 r208246  
    1717function test()
    1818{
     19    let domTree = WebInspector.frameResourceManager.mainFrame.domTree;
     20
    1921    function onRootDOMNodeInvalidated()
    2022    {
    21         WebInspector.frameResourceManager.mainFrame.domTree.requestContentFlowList();
     23        domTree.requestContentFlowList();
    2224    }
    2325
    2426    function onContentFlowWasAdded(event)
    2527    {
    26         InspectorTest.expectThat(event.data.flow.name === "flow1", "ContentFlow was added");
    27         InspectorTest.expectThat(WebInspector.frameResourceManager.mainFrame.domTree.flowsCount === 1, "Flow count is 1");
     28        InspectorTest.expectEqual(event.data.flow.name, "flow1", "ContentFlow was added");
     29        InspectorTest.expectEqual(domTree.contentFlowCollection.items.size, 1, "Flow count is 1");
    2830
    2931        InspectorTest.evaluateInPage("removeFlow()");
     
    3234    function onContentFlowWasRemoved(event)
    3335    {
    34         InspectorTest.expectThat(event.data.flow.name === "flow1", "ContentFlow was removed");
    35         InspectorTest.expectThat(WebInspector.frameResourceManager.mainFrame.domTree.flowsCount === 0, "Flow count is 0");
     36        InspectorTest.expectEqual(event.data.flow.name, "flow1", "ContentFlow was removed");
     37        InspectorTest.expectEqual(domTree.contentFlowCollection.items.size, 0, "Flow count is 0");
    3638        InspectorTest.completeTest();
    3739    }
    3840
    3941    WebInspector.Frame.addEventListener(WebInspector.Frame.Event.MainResourceDidChange, function() {
    40         var domTree = WebInspector.frameResourceManager.mainFrame.domTree;
    41         domTree.addEventListener(WebInspector.DOMTree.Event.RootDOMNodeInvalidated, onRootDOMNodeInvalidated, null);
    42         domTree.addEventListener(WebInspector.DOMTree.Event.ContentFlowWasAdded, onContentFlowWasAdded, null);
    43         domTree.addEventListener(WebInspector.DOMTree.Event.ContentFlowWasRemoved, onContentFlowWasRemoved, null);
     42        domTree.addEventListener(WebInspector.DOMTree.Event.RootDOMNodeInvalidated, onRootDOMNodeInvalidated);
     43        domTree.addEventListener(WebInspector.DOMTree.Event.ContentFlowWasAdded, onContentFlowWasAdded);
     44        domTree.addEventListener(WebInspector.DOMTree.Event.ContentFlowWasRemoved, onContentFlowWasRemoved);
    4445        domTree.requestContentFlowList();
    4546    });
  • trunk/LayoutTests/inspector/dom/highlightFrame-expected.txt

    r189416 r208246  
    22
    33 
     4PASS: Page should have subframes.
    45
    56== Running test suite: DOM.highlightFrame
  • trunk/LayoutTests/inspector/dom/highlightFrame.html

    r189416 r208246  
    66function test()
    77{
    8     InspectorTest.assert(WebInspector.frameResourceManager.mainFrame.childFrames.length === 2, "Page should have subframes.");
    9     const mainFrame = WebInspector.frameResourceManager.mainFrame;
    10     const childFrame1 = WebInspector.frameResourceManager.mainFrame.childFrames[0];
    11     const childFrame2 = WebInspector.frameResourceManager.mainFrame.childFrames[1];
     8    let suite = InspectorTest.createAsyncSuite("DOM.highlightFrame");
     9
     10    let mainFrame = WebInspector.frameResourceManager.mainFrame;
     11    let childFrames = mainFrame.childFrameCollection.toArray();
     12    InspectorTest.expectEqual(childFrames.length, 2, "Page should have subframes.");
    1213
    1314    function getHighlight(callback) {
     
    2627    }
    2728
    28     let suite = InspectorTest.createAsyncSuite("DOM.highlightFrame");
    29 
    3029    suite.addTestCase({
    3130        name: "CheckEmptyHighlight",
    3231        description: "Should not be a highlight yet.",
    33         test: (resolve, reject) => {
     32        test(resolve, reject) {
    3433            getHighlight((highlightObjectPayload) => {
    3534                InspectorTest.expectThat(highlightObjectPayload.length === 0, "Should not be a highlight yet.");
     
    4241        name: "HighlightMainFrame",
    4342        description: "Main frame does not have an owner element, so there will be no highlight.",
    44         test: (resolve, reject) => {
     43        test(resolve, reject) {
    4544            DOMAgent.highlightFrame(mainFrame.id, undefined, undefined, (error) => {
    4645                getHighlight((highlightObjectPayload) => {
     
    5554        name: "HighlightChildFrame1",
    5655        description: "Should highlight child frame 1.",
    57         test: (resolve, reject) => {
    58             DOMAgent.highlightFrame(childFrame1.id, undefined, undefined, (error) => {
     56        test(resolve, reject) {
     57            DOMAgent.highlightFrame(childFrames[0].id, undefined, undefined, (error) => {
    5958                InspectorTest.assert(!error, "Should not have an error.");
    6059                dumpHighlight(resolve);
     
    6665        name: "HighlightChildFrame2",
    6766        description: "Should highlight child frame 2.",
    68         test: (resolve, reject) => {
    69             DOMAgent.highlightFrame(childFrame2.id, undefined, undefined, (error) => {
     67        test(resolve, reject) {
     68            DOMAgent.highlightFrame(childFrames[1].id, undefined, undefined, (error) => {
    7069                InspectorTest.assert(!error, "Should not have an error.");
    7170                dumpHighlight(resolve);
     
    7978        name: "BadFrameId",
    8079        description: "Bad frame id should cause an error.",
    81         test: (resolve, reject) => {
     80        test(resolve, reject) {
    8281            DOMAgent.highlightFrame("bad-frame-id", undefined, undefined, (error) => {
    8382                InspectorTest.expectThat(error, "Should produce an error.");
  • trunk/LayoutTests/inspector/dom/highlightNode-expected.txt

    r205035 r208246  
    22
    33
     4PASS: Page should have a subframe.
    45
    56== Running test suite: DOM.highlightNode
  • trunk/LayoutTests/inspector/dom/highlightNode.html

    r189416 r208246  
    66function test()
    77{
    8     InspectorTest.assert(WebInspector.frameResourceManager.mainFrame.childFrames.length === 1, "Page should have a subframe.");
    9     const mainFrame = WebInspector.frameResourceManager.mainFrame;
    10     const childFrame = WebInspector.frameResourceManager.mainFrame.childFrames[0];
     8    let suite = InspectorTest.createAsyncSuite("DOM.highlightNode");
     9
     10    let mainFrame = WebInspector.frameResourceManager.mainFrame;
     11    let childFrames = mainFrame.childFrameCollection.toArray();
     12    InspectorTest.expectEqual(childFrames.length, 1, "Page should have a subframe.");
     13
    1114    const highlightConfig = {
    1215        showInfo: true,
     
    2730    function dumpHighlight(callback) {
    2831        getHighlight((highlightObjectPayload) => {
    29             InspectorTest.expectThat(highlightObjectPayload.length === 1, "Should be one highlighted node.");
     32            InspectorTest.expectEqual(highlightObjectPayload.length, 1, "Should be one highlighted node.");
    3033            InspectorTest.log("Highlighted Element Data: " + JSON.stringify(highlightObjectPayload[0].elementData));
    3134            callback();
     
    3740    let childFrameDocumentNodeId, childFrameTargetNode;
    3841
    39     let suite = InspectorTest.createAsyncSuite("DOM.highlightNode");
    40 
    4142    suite.addTestCase({
    4243        name: "CheckEmptyHighlight",
    4344        description: "Should not be a highlight yet.",
    44         test: (resolve, reject) => {
     45        test(resolve, reject) {
    4546            getHighlight((highlightObjectPayload) => {
    46                 InspectorTest.expectThat(highlightObjectPayload.length === 0, "Should not be a highlight yet.");
     47                InspectorTest.expectEqual(highlightObjectPayload.length, 0, "Should not be a highlight yet.");
    4748                resolve();
    4849            });
     
    5354        name: "MainFrameNodeViaNodeId",
    5455        description: "Should highlight a node in the main frame using node id.",
    55         test: (resolve, reject) => {
     56        test(resolve, reject) {
    5657            WebInspector.domTreeManager.querySelector(mainFrameDocumentNodeId, "#id-one", function(nodeId) {
    5758                mainFrameTargetNode = WebInspector.domTreeManager.nodeForId(nodeId);
     
    6768        name: "ChildFrameNodeViaNodeId",
    6869        description: "Should highlight a node in the child frame using node id.",
    69         test: (resolve, reject) => {
     70        test(resolve, reject) {
    7071            WebInspector.domTreeManager.querySelector(childFrameDocumentNodeId, "#id-one", function(nodeId) {
    7172                childFrameTargetNode = WebInspector.domTreeManager.nodeForId(nodeId);
     
    8182        name: "MainFrameNodeViaObjectId",
    8283        description: "Should highlight a node in the main frame using object id.",
    83         test: (resolve, reject) => {
     84        test(resolve, reject) {
    8485            WebInspector.RemoteObject.resolveNode(mainFrameTargetNode, "test", (remoteObject) => {
    8586                DOMAgent.highlightNode(highlightConfig, undefined, remoteObject.objectId, (error) => {
     
    9495        name: "ChildFrameNodeViaObjectId",
    9596        description: "Should highlight a node in the child frame using object id.",
    96         test: (resolve, reject) => {
     97        test(resolve, reject) {
    9798            WebInspector.RemoteObject.resolveNode(childFrameTargetNode, "test", (remoteObject) => {
    9899                DOMAgent.highlightNode(highlightConfig, undefined, remoteObject.objectId, (error) => {
     
    109110        name: "MissingNodeAndObjectIdShouldError",
    110111        description: "Missing identifiers should cause an error.",
    111         test: (resolve, reject) => {
     112        test(resolve, reject) {
    112113            DOMAgent.highlightNode(highlightConfig, undefined, undefined, (error) => {
    113114                InspectorTest.expectThat(error, "Should produce an error.");
     
    121122        name: "BadNodeId",
    122123        description: "Bad node id should cause an error.",
    123         test: (resolve, reject) => {
     124        test(resolve, reject) {
    124125            DOMAgent.highlightNode(highlightConfig, 9999999, undefined, (error) => {
    125126                InspectorTest.expectThat(error, "Should produce an error.");
     
    133134        name: "BadObjectId",
    134135        description: "Bad object id should cause an error.",
    135         test: (resolve, reject) => {
     136        test(resolve, reject) {
    136137            DOMAgent.highlightNode(highlightConfig, undefined, "bad-object-id", (error) => {
    137138                InspectorTest.expectThat(error, "Should produce an error.");
     
    144145    WebInspector.domTreeManager.requestDocument((documentNode) => {
    145146        mainFrameDocumentNodeId = documentNode.id;
    146         RuntimeAgent.evaluate.invoke({expression: "document", objectGroup: "test", contextId: childFrame.pageExecutionContext.id}, (error, remoteObjectPayload) => {
     147        RuntimeAgent.evaluate.invoke({expression: "document", objectGroup: "test", contextId: childFrames[0].pageExecutionContext.id}, (error, remoteObjectPayload) => {
    147148            let remoteObject = WebInspector.RemoteObject.fromPayload(remoteObjectPayload)
    148149            remoteObject.pushNodeToFrontend((documentNodeId) => {
  • trunk/LayoutTests/inspector/dom/highlightSelector-expected.txt

    r205035 r208246  
    22
    33
     4PASS: Page should have a subframe.
    45
    56== Running test suite: DOM.highlightSelector
  • trunk/LayoutTests/inspector/dom/highlightSelector.html

    r205035 r208246  
    66function test()
    77{
    8     InspectorTest.assert(WebInspector.frameResourceManager.mainFrame.childFrames.length === 1, "Page should have a subframe.");
    9     const mainFrameId = WebInspector.frameResourceManager.mainFrame.id;
    10     const childFrameId = WebInspector.frameResourceManager.mainFrame.childFrames[0].id;
     8    let suite = InspectorTest.createAsyncSuite("DOM.highlightSelector");
     9
     10    let mainFrame = WebInspector.frameResourceManager.mainFrame;
     11    let childFrames = mainFrame.childFrameCollection.toArray();
     12    InspectorTest.expectEqual(childFrames.length, 1, "Page should have a subframe.");
     13
     14    let mainFrameId = mainFrame.id;
     15    let childFrameId = childFrames[0].id;
     16
    1117    const highlightConfig = {
    1218        showInfo: true,
     
    103109    }
    104110
    105     let suite = InspectorTest.createAsyncSuite("DOM.highlightSelector");
    106 
    107     for (let testcase of tests) {
    108         let {name, frameId, selector, expectedElements, expectError} = testcase;
     111    for (let {name, frameId, selector, expectedElements, expectError} of tests) {
    109112        suite.addTestCase({
    110113            name,
    111             test: (resolve, reject) => {
     114            test(resolve, reject) {
    112115                InspectorTest.log("- Frame: " + displayNameForFrameId(frameId));
    113116                InspectorTest.log("- Selector: " + selector);
  • trunk/LayoutTests/inspector/model/frame-extra-scripts-expected.txt

    r200065 r208246  
    11CONSOLE MESSAGE: line 1: dynamically added script element
    2 WebInspector.Frame.extraScripts.
     2WebInspector.Frame.extraScriptCollection.
    33
    44
    5 == Running test suite: WebInspector.Frame.extraScripts
     5== Running test suite: WebInspector.Frame.extraScriptCollection
    66-- Running test case: FrameHasNoExtraScriptsYet
    77PASS: Main frame should have no dynamic scripts.
  • trunk/LayoutTests/inspector/model/frame-extra-scripts.html

    r206152 r208246  
    1212function test()
    1313{
    14     let suite = InspectorTest.createAsyncSuite("WebInspector.Frame.extraScripts");
     14    let suite = InspectorTest.createAsyncSuite("WebInspector.Frame.extraScriptCollection");
     15
     16    let mainFrame = WebInspector.frameResourceManager.mainFrame;
    1517
    1618    suite.addTestCase({
     
    1820        description: "No extra scripts yet.",
    1921        test(resolve, reject) {
    20             let mainFrame = WebInspector.frameResourceManager.mainFrame;
    21             InspectorTest.expectThat(mainFrame.extraScripts.length === 0, "Main frame should have no dynamic scripts.");
     22            InspectorTest.expectEqual(mainFrame.extraScriptCollection.items.size, 0, "Main frame should have no dynamic scripts.");
    2223            resolve();
    2324        }
     
    3233                InspectorTest.pass("ExtraScriptAdded event fired.");
    3334                InspectorTest.expectThat(event.data.script.dynamicallyAddedScriptElement, "Script should identify as dynamic.");
    34 
    35                 let mainFrame = WebInspector.frameResourceManager.mainFrame;
    36                 InspectorTest.expectThat(mainFrame.extraScripts.length === 1, "Main frame should have 1 dynamic script.");
     35                InspectorTest.expectEqual(mainFrame.extraScriptCollection.items.size, 1, "Main frame should have 1 dynamic script.");
    3736            })
    3837            .then(resolve, reject);
     
    4746</head>
    4847<body onload="runTest()">
    49 <p>WebInspector.Frame.extraScripts.</p>
     48<p>WebInspector.Frame.extraScriptCollection.</p>
    5049</body>
    5150</html>
  • trunk/Source/WebInspectorUI/ChangeLog

    r208234 r208246  
     12016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>
     2
     3        Web Inspector: Replace sublists inside DOM-related model objects with WI.Collection
     4        https://bugs.webkit.org/show_bug.cgi?id=164098
     5
     6        Reviewed by Timothy Hatcher.
     7
     8        * UserInterface/Models/DOMTree.js:
     9        * UserInterface/Models/Frame.js:
     10        Add support for WebInspector.Collection.
     11
     12        * UserInterface/Models/Script.js:
     13        (WebInspector.Script):
     14        * UserInterface/Views/DebuggerSidebarPanel.js:
     15        (WebInspector.DebuggerSidebarPanel.prototype._addResourcesRecursivelyForFrame):
     16        * UserInterface/Views/FrameTreeElement.js:
     17        (WebInspector.FrameTreeElement):
     18        (WebInspector.FrameTreeElement.prototype.onpopulate):
     19        * UserInterface/Views/OpenResourceDialog.js:
     20        (WebInspector.OpenResourceDialog.prototype._addResourcesForFrame):
     21        Use new functions defined by changing to WebInspector.Collection.
     22
    1232016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>
    224
  • trunk/Source/WebInspectorUI/UserInterface/Models/Collection.js

    r208012 r208246  
    113113 WebInspector.Collection.TypeVerifier = {
    114114    Any: (object) => true,
     115    ContentFlow: (object) => object instanceof WebInspector.ContentFlow,
    115116    Frame: (object) => object instanceof WebInspector.Frame,
    116117    Resource: (object) => object instanceof WebInspector.Resource,
  • trunk/Source/WebInspectorUI/UserInterface/Models/DOMTree.js

    r188993 r208246  
    3434        this._rootDOMNode = null;
    3535        this._requestIdentifier = 0;
    36         this._flowMap = {};
     36        this._contentFlowCollection = new WebInspector.Collection(WebInspector.Collection.TypeVerifier.ContentFlow);
    3737
    3838        this._frame.addEventListener(WebInspector.Frame.Event.PageExecutionContextChanged, this._framePageExecutionContextChanged, this);
     
    5353    // Public
    5454
    55     get frame()
    56     {
    57         return this._frame;
    58     }
    59 
    60     get flowMap()
    61     {
    62         return this._flowMap;
    63     }
    64 
    65     get flowsCount()
    66     {
    67         return Object.keys(this._flowMap).length;
    68     }
     55    get frame() { return this._frame; }
     56    get contentFlowCollection() { return this._contentFlowCollection; }
    6957
    7058    disconnect()
     
    264252
    265253        // Assume that all the flows have been removed.
    266         var deletedFlows = {};
    267         for (var flowId in this._flowMap)
    268             deletedFlows[flowId] = this._flowMap[flowId];
    269 
    270         var newFlows = [];
    271 
    272         var flows = event.data.flows;
    273         for (var i = 0; i < flows.length; ++i) {
    274             var flow = flows[i];
     254        let deletedFlows = new Set(this._contentFlowCollection.items);
     255        let newFlows = new Set;
     256        for (let flow of event.data.flows) {
    275257            // All the flows received from WebKit are part of the same document.
    276258            console.assert(this._isContentFlowInCurrentDocument(flow));
    277259
    278             var flowId = flow.id;
    279             if (this._flowMap.hasOwnProperty(flowId)) {
     260            if (this._contentFlowCollection.items.has(flow)) {
    280261                // Remove the flow name from the deleted list.
    281                 console.assert(deletedFlows.hasOwnProperty(flowId));
    282                 delete deletedFlows[flowId];
     262                console.assert(deletedFlows.has(flow));
     263                deletedFlows.delete(flow);
    283264            } else {
    284                 this._flowMap[flowId] = flow;
    285                 newFlows.push(flow);
     265                this._contentFlowCollection.add(flow);
     266                newFlows.add(flow);
    286267            }
    287268        }
    288269
    289         for (var flowId in deletedFlows) {
    290             delete this._flowMap[flowId];
    291         }
     270        for (let flow of deletedFlows)
     271            this._contentFlowCollection.remove(flow);
    292272
    293273        // Send update events to listeners.
    294274
    295         for (var flowId in deletedFlows)
    296             this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasRemoved, {flow: deletedFlows[flowId]});
    297 
    298         for (var i = 0; i < newFlows.length; ++i)
    299             this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasAdded, {flow: newFlows[i]});
     275        for (let flow of deletedFlows)
     276            this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasRemoved, {flow});
     277
     278        for (let flow of newFlows)
     279            this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasAdded, {flow});
    300280    }
    301281
    302282    _contentFlowWasAdded(event)
    303283    {
    304         var flow = event.data.flow;
     284        let flow = event.data.flow;
    305285        if (!this._isContentFlowInCurrentDocument(flow))
    306286            return;
    307287
    308         var flowId = flow.id;
    309         console.assert(!this._flowMap.hasOwnProperty(flowId));
    310         this._flowMap[flowId] = flow;
     288        this._contentFlowCollection.add(flow);
    311289
    312290        this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasAdded, {flow});
     
    315293    _contentFlowWasRemoved(event)
    316294    {
    317         var flow = event.data.flow;
     295        let flow = event.data.flow;
    318296        if (!this._isContentFlowInCurrentDocument(flow))
    319297            return;
    320298
    321         var flowId = flow.id;
    322         console.assert(this._flowMap.hasOwnProperty(flowId));
    323         delete this._flowMap[flowId];
     299        this._contentFlowCollection.remove(flow);
    324300
    325301        this.dispatchEventToListeners(WebInspector.DOMTree.Event.ContentFlowWasRemoved, {flow});
  • trunk/Source/WebInspectorUI/UserInterface/Models/Frame.js

    r208012 r208246  
    3939        this._resourceCollection = new WebInspector.ResourceCollection;
    4040        this._provisionalResourceCollection = new WebInspector.ResourceCollection;
    41         this._extraScripts = [];
    42 
    43         this._childFrames = [];
     41        this._extraScriptCollection = new WebInspector.Collection(WebInspector.Collection.TypeVerifier.Script);
     42
     43        this._childFrameCollection = new WebInspector.Collection(WebInspector.Collection.TypeVerifier.Frame);
    4444        this._childFrameIdentifierMap = new Map;
    4545
     
    5858
    5959    get resourceCollection() { return this._resourceCollection; }
     60    get extraScriptCollection() { return this._extraScriptCollection; }
     61    get childFrameCollection() { return this._childFrameCollection; }
    6062
    6163    initialize(name, securityOrigin, loaderIdentifier, mainResource)
     
    131133        this._resourceCollection = this._provisionalResourceCollection;
    132134        this._provisionalResourceCollection = new WebInspector.ResourceCollection;
    133         this._extraScripts = [];
     135        this._extraScriptCollection.clear();
    134136
    135137        this.clearExecutionContexts(true);
     
    236238    {
    237239        return this._parentFrame;
    238     }
    239 
    240     get childFrames()
    241     {
    242         return this._childFrames;
    243240    }
    244241
     
    307304            frame._parentFrame.removeChildFrame(frame);
    308305
    309         this._childFrames.push(frame);
     306        this._childFrameCollection.add(frame);
    310307        this._childFrameIdentifierMap.set(frame._id, frame);
    311308
     
    319316        console.assert(frameOrFrameId);
    320317
    321         if (frameOrFrameId instanceof WebInspector.Frame)
    322             var childFrameId = frameOrFrameId._id;
    323         else
    324             var childFrameId = frameOrFrameId;
     318        let childFrameId = frameOrFrameId;
     319        if (childFrameId instanceof WebInspector.Frame)
     320            childFrameId = frameOrFrameId._id;
    325321
    326322        // Fetch the frame by id even if we were passed a WebInspector.Frame.
    327         // We do this incase the WebInspector.Frame is a new object that isn't in _childFrames,
    328         // but the id is a valid child frame.
    329         var childFrame = this.childFrameForIdentifier(childFrameId);
     323        // We do this incase the WebInspector.Frame is a new object that isn't
     324        // in _childFrameCollection, but the id is a valid child frame.
     325        let childFrame = this.childFrameForIdentifier(childFrameId);
    330326        console.assert(childFrame instanceof WebInspector.Frame);
    331327        if (!(childFrame instanceof WebInspector.Frame))
     
    334330        console.assert(childFrame.parentFrame === this);
    335331
    336         this._childFrames.remove(childFrame);
     332        this._childFrameCollection.remove(childFrame);
    337333        this._childFrameIdentifierMap.delete(childFrame._id);
    338334
     
    346342        this._detachFromParentFrame();
    347343
    348         for (let childFrame of this._childFrames)
     344        for (let childFrame of this._childFrameCollection.items)
    349345            childFrame.removeAllChildFrames();
    350346
    351         this._childFrames = [];
     347        this._childFrameCollection.clear();
    352348        this._childFrameIdentifierMap.clear();
    353349
     
    362358
    363359        // Check the main resources of the child frames for the requested URL.
    364         for (var i = 0; i < this._childFrames.length; ++i) {
    365             resource = this._childFrames[i].mainResource;
     360        for (let childFrame of this._childFrameCollection.items) {
     361            resource = childFrame.mainResource;
    366362            if (resource.url === url)
    367363                return resource;
     
    372368
    373369        // Recursively search resources of child frames.
    374         for (var i = 0; i < this._childFrames.length; ++i) {
    375             resource = this._childFrames[i].resourceForURL(url, true);
     370        for (let childFrame of this._childFrameCollection.items) {
     371            resource = childFrame.resourceForURL(url, true);
    376372            if (resource)
    377373                return resource;
     
    409405    }
    410406
    411     removeResource(resourceOrURL)
     407    removeResource(resource)
    412408    {
    413409        // This does not remove provisional resources.
    414410
    415         var resource = this._resourceCollection.remove(resourceOrURL);
    416         if (!resource)
    417             return;
     411        this._resourceCollection.remove(resource);
    418412
    419413        this._disassociateWithResource(resource);
     
    438432    }
    439433
    440     get extraScripts()
    441     {
    442         return this._extraScripts;
    443     }
    444 
    445434    addExtraScript(script)
    446435    {
    447         this._extraScripts.push(script);
     436        this._extraScriptCollection.add(script);
    448437
    449438        this.dispatchEventToListeners(WebInspector.Frame.Event.ExtraScriptAdded, {script});
  • trunk/Source/WebInspectorUI/UserInterface/Models/Script.js

    r206654 r208246  
    5353            this._dynamicallyAddedScriptElement = true;
    5454            documentResource.parentFrame.addExtraScript(this);
    55             this._dynamicallyAddedScriptElementNumber = documentResource.parentFrame.extraScripts.length;
     55            this._dynamicallyAddedScriptElementNumber = documentResource.parentFrame.extraScriptCollection.items.size;
    5656        } else if (this._resource)
    5757            this._resource.associateWithScript(this);
  • trunk/Source/WebInspectorUI/UserInterface/Views/DebuggerSidebarPanel.js

    r208012 r208246  
    423423            this._addResource(resource);
    424424
    425         for (var childFrame of frame.childFrames)
     425        for (let childFrame of frame.childFrameCollection.items)
    426426            this._addResourcesRecursivelyForFrame(childFrame);
    427427    }
  • trunk/Source/WebInspectorUI/UserInterface/Views/FrameTreeElement.js

    r208012 r208246  
    5252        this.registerFolderizeSettings("frames", WebInspector.UIString("Frames"),
    5353            (representedObject) => representedObject instanceof WebInspector.Frame,
    54             () => this.frame.childFrames.length,
     54            () => this.frame.childFrameCollection.items.size,
    5555            WebInspector.FrameTreeElement
    5656        );
     
    5858        this.registerFolderizeSettings("flows", WebInspector.UIString("Flows"),
    5959            (representedObject) => representedObject instanceof WebInspector.ContentFlow,
    60             () => this.frame.domTree.flowsCount,
     60            () => this.frame.domTree.contentFlowCollection.items.size,
    6161            WebInspector.ContentFlowTreeElement
    6262        );
     
    6464        this.registerFolderizeSettings("extra-scripts", WebInspector.UIString("Extra Scripts"),
    6565            (representedObject) => representedObject instanceof WebInspector.Script && representedObject.dynamicallyAddedScriptElement,
    66             () => this.frame.extraScripts.length,
     66            () => this.frame.extraScriptCollection.items.size,
    6767            WebInspector.ScriptTreeElement
    6868        );
     
    179179        this.prepareToPopulate();
    180180
    181         for (var i = 0; i < this._frame.childFrames.length; ++i)
    182             this.addChildForRepresentedObject(this._frame.childFrames[i]);
     181        for (let frame of this._frame.childFrameCollection.items)
     182            this.addChildForRepresentedObject(frame);
    183183
    184184        for (let resource of this._frame.resourceCollection.items)
     
    192192        }
    193193
    194         var flowMap = this._frame.domTree.flowMap;
    195         for (var flowKey in flowMap)
    196             this.addChildForRepresentedObject(flowMap[flowKey]);
    197 
    198         for (let extraScript of this._frame.extraScripts) {
     194        for (let contentFlow of this._frame.domTree.contentFlowCollection.items)
     195            this.addChildForRepresentedObject(contentFlow);
     196
     197        for (let extraScript of this._frame.extraScriptCollection.items) {
    199198            if (extraScript.sourceURL || extraScript.sourceMappingURL)
    200199                this.addChildForRepresentedObject(extraScript);
  • trunk/Source/WebInspectorUI/UserInterface/Views/OpenResourceDialog.js

    r208012 r208246  
    273273                this._addResource(resource, suppressFilterUpdate);
    274274
    275             frames = frames.concat(currentFrame.childFrames);
     275            frames = frames.concat(currentFrame.childFrameCollection.toArray());
    276276        }
    277277
Note: See TracChangeset for help on using the changeset viewer.