Changeset 208012 in webkit


Ignore:
Timestamp:
Oct 27, 2016 3:25:24 PM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Web Inspector: Create general model object Collection class
​https://bugs.webkit.org/show_bug.cgi?id=163995

Patch by Devin Rousso <Devin Rousso> on 2016-10-27
Reviewed by Joseph Pecoraro.

Source/WebInspectorUI:

  • UserInterface/Models/Collection.js: Added.

(WebInspector.Collection):
(WebInspector.Collection.prototype.get items):
(WebInspector.Collection.prototype.get typeVerifier):
(WebInspector.Collection.prototype.add):
(WebInspector.Collection.prototype.remove):
(WebInspector.Collection.prototype.clear):
(WebInspector.Collection.prototype.toArray):
(WebInspector.Collection.prototype.toJSON):
(WebInspector.Collection.prototype.itemAdded):
(WebInspector.Collection.prototype.itemRemoved):
(WebInspector.Collection.prototype.itemsCleared):
Class that holds multiple model objects. It can be limited to a specific type by supplying
a "typeVerifier", which is a function that accepts a single argument (the model object) and
returns true/false depending on if that argument matches the "type" of the collection.

  • UserInterface/Main.html:
  • UserInterface/Test.html:
  • UserInterface/Models/Frame.js:
  • UserInterface/Views/CookieStorageContentView.js:
  • UserInterface/Views/DebuggerSidebarPanel.js:
  • UserInterface/Views/FrameTreeElement.js:
  • UserInterface/Views/OpenResourceDialog.js:

Add support for WebInspector.Collection.

  • UserInterface/Models/ResourceCollection.js:

(WebInspector.ResourceCollection):
(WebInspector.ResourceCollection.verifierForType):
(WebInspector.ResourceCollection.prototype.resourceCollectionForType):
(WebInspector.ResourceCollection.prototype.clear):
(WebInspector.ResourceCollection.prototype.itemAdded):
(WebInspector.ResourceCollection.prototype.itemRemoved):
(WebInspector.ResourceCollection.prototype.itemsCleared):
(WebInspector.ResourceCollection.prototype._associateWithResource):
(WebInspector.ResourceCollection.prototype._disassociateWithResource):
(WebInspector.ResourceCollection.prototype._resourceURLDidChange):
(WebInspector.ResourceCollection.prototype._resourceTypeDidChange):
(WebInspector.ResourceCollection.prototype.get resources): Deleted.
(WebInspector.ResourceCollection.prototype.resourcesWithType): Deleted.
(WebInspector.ResourceCollection.prototype.addResource): Deleted.
(WebInspector.ResourceCollection.prototype.removeResource): Deleted.
(WebInspector.ResourceCollection.prototype.removeAllResources): Deleted.
Now a subclass of WebInspector.Collection. Retrieving WebInspector.Resource objects by type
and URL is still supported, but requesting by type now returns another instance of
WebInspector.ResourceCollection that is configured to only accept the requested type.

LayoutTests:

  • inspector/debugger/resources/log-pause-location.js:

(TestPage.registerInitializer.window.findScript):
Change name of getter to support WebInspector.Collection.

  • inspector/unit-tests/collection-expected.txt: Added.
  • inspector/unit-tests/collection.html: Added.
  • inspector/unit-tests/resource-collection-expected.txt: Added.
  • inspector/unit-tests/resource-collection.html: Added.

Created tests for WebInspector.Collection and WebInspector.ResourceCollection.

Location:
trunk
Files:
5 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r208011 r208012  
     12016-10-27  Devin Rousso  <dcrousso+webkit@gmail.com>
     2
     3        Web Inspector: Create general model object Collection class
     4        https://bugs.webkit.org/show_bug.cgi?id=163995
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * inspector/debugger/resources/log-pause-location.js:
     9        (TestPage.registerInitializer.window.findScript):
     10        Change name of getter to support WebInspector.Collection.
     11
     12        * inspector/unit-tests/collection-expected.txt: Added.
     13        * inspector/unit-tests/collection.html: Added.
     14        * inspector/unit-tests/resource-collection-expected.txt: Added.
     15        * inspector/unit-tests/resource-collection.html: Added.
     16        Created tests for WebInspector.Collection and WebInspector.ResourceCollection.
     17
    1182016-10-27  Joseph Pecoraro  <pecoraro@apple.com>
    219

  • trunk/LayoutTests/inspector/debugger/resources/log-pause-location.js

    r206693 r208012  
    1717
    1818    window.findScript = function(regex) {
    19         let resources = WebInspector.frameResourceManager.mainFrame.resources;
     19        let resources = WebInspector.frameResourceManager.mainFrame.resourceCollection.items;
    2020        for (let resource of resources) {
    2121            if (regex.test(resource.url))

  • trunk/Source/WebInspectorUI/ChangeLog

    r208010 r208012  
     12016-10-27  Devin Rousso  <dcrousso+webkit@gmail.com>
     2
     3        Web Inspector: Create general model object Collection class
     4        https://bugs.webkit.org/show_bug.cgi?id=163995
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * UserInterface/Models/Collection.js: Added.
     9        (WebInspector.Collection):
     10        (WebInspector.Collection.prototype.get items):
     11        (WebInspector.Collection.prototype.get typeVerifier):
     12        (WebInspector.Collection.prototype.add):
     13        (WebInspector.Collection.prototype.remove):
     14        (WebInspector.Collection.prototype.clear):
     15        (WebInspector.Collection.prototype.toArray):
     16        (WebInspector.Collection.prototype.toJSON):
     17        (WebInspector.Collection.prototype.itemAdded):
     18        (WebInspector.Collection.prototype.itemRemoved):
     19        (WebInspector.Collection.prototype.itemsCleared):
     20        Class that holds multiple model objects.  It can be limited to a specific type by supplying
     21        a "typeVerifier", which is a function that accepts a single argument (the model object) and
     22        returns true/false depending on if that argument matches the "type" of the collection.
     23
     24        * UserInterface/Main.html:
     25        * UserInterface/Test.html:
     26        * UserInterface/Models/Frame.js:
     27        * UserInterface/Views/CookieStorageContentView.js:
     28        * UserInterface/Views/DebuggerSidebarPanel.js:
     29        * UserInterface/Views/FrameTreeElement.js:
     30        * UserInterface/Views/OpenResourceDialog.js:
     31        Add support for WebInspector.Collection.
     32       
     33        * UserInterface/Models/ResourceCollection.js:
     34        (WebInspector.ResourceCollection):
     35        (WebInspector.ResourceCollection.verifierForType):
     36        (WebInspector.ResourceCollection.prototype.resourceCollectionForType):
     37        (WebInspector.ResourceCollection.prototype.clear):
     38        (WebInspector.ResourceCollection.prototype.itemAdded):
     39        (WebInspector.ResourceCollection.prototype.itemRemoved):
     40        (WebInspector.ResourceCollection.prototype.itemsCleared):
     41        (WebInspector.ResourceCollection.prototype._associateWithResource):
     42        (WebInspector.ResourceCollection.prototype._disassociateWithResource):
     43        (WebInspector.ResourceCollection.prototype._resourceURLDidChange):
     44        (WebInspector.ResourceCollection.prototype._resourceTypeDidChange):
     45        (WebInspector.ResourceCollection.prototype.get resources): Deleted.
     46        (WebInspector.ResourceCollection.prototype.resourcesWithType): Deleted.
     47        (WebInspector.ResourceCollection.prototype.addResource): Deleted.
     48        (WebInspector.ResourceCollection.prototype.removeResource): Deleted.
     49        (WebInspector.ResourceCollection.prototype.removeAllResources): Deleted.
     50        Now a subclass of WebInspector.Collection.  Retrieving WebInspector.Resource objects by type
     51        and URL is still supported, but requesting by type now returns another instance of
     52        WebInspector.ResourceCollection that is configured to only accept the requested type.
     53
    1542016-10-27  Joseph Pecoraro  <pecoraro@apple.com>
    255

  • trunk/Source/WebInspectorUI/UserInterface/Main.html

    r208009 r208012  
    302302    <script src="Models/CSSStyleSheet.js"></script>
    303303    <script src="Models/CallFrame.js"></script>
     304    <script src="Models/Collection.js"></script>
    304305    <script src="Models/CollectionEntry.js"></script>
    305306    <script src="Models/CollectionEntryPreview.js"></script>

  • trunk/Source/WebInspectorUI/UserInterface/Models/Frame.js

    r205426 r208012  
    4242
    4343        this._childFrames = [];
    44         this._childFrameIdentifierMap = {};
     44        this._childFrameIdentifierMap = new Map;
    4545
    4646        this._parentFrame = null;
    … …  
    5656
    5757    // Public
     58
     59    get resourceCollection() { return this._resourceCollection; }
    5860
    5961    initialize(name, securityOrigin, loaderIdentifier, mainResource)
    … …  
    100102        this._provisionalLoaderIdentifier = provisionalMainResource.loaderIdentifier;
    101103
    102         this._provisionalResourceCollection.removeAllResources();
     104        this._provisionalResourceCollection.clear();
    103105
    104106        this.dispatchEventToListeners(WebInspector.Frame.Event.ProvisionalLoadStarted);
    … …  
    151153        this._provisionalLoaderIdentifier = null;
    152154        this._provisionalMainResource = null;
    153         this._provisionalResourceCollection.removeAllResources();
     155        this._provisionalResourceCollection.clear();
    154156
    155157        if (!skipProvisionalLoadClearedEvent)
    … …  
    290292    childFrameForIdentifier(frameId)
    291293    {
    292         return this._childFrameIdentifierMap[frameId] || null;
     294        return this._childFrameIdentifierMap.get(frameId) || null;
    293295    }
    294296
    … …  
    306308
    307309        this._childFrames.push(frame);
    308         this._childFrameIdentifierMap[frame._id] = frame;
     310        this._childFrameIdentifierMap.set(frame._id, frame);
    309311
    310312        frame._parentFrame = this;
    … …  
    333335
    334336        this._childFrames.remove(childFrame);
    335         delete this._childFrameIdentifierMap[childFrame._id];
     337        this._childFrameIdentifierMap.delete(childFrame._id);
    336338
    337339        childFrame._detachFromParentFrame();
    … …  
    348350
    349351        this._childFrames = [];
    350         this._childFrameIdentifierMap = {};
     352        this._childFrameIdentifierMap.clear();
    351353
    352354        this.dispatchEventToListeners(WebInspector.Frame.Event.AllChildFramesRemoved);
    353     }
    354 
    355     get resources()
    356     {
    357         return this._resourceCollection.resources;
    358355    }
    359356
    … …  
    384381    }
    385382
    386     resourcesWithType(type)
    387     {
    388         return this._resourceCollection.resourcesWithType(type);
     383    resourceCollectionForType(type)
     384    {
     385        return this._resourceCollection.resourceCollectionForType(type);
    389386    }
    390387
    … …  
    399396
    400397        if (resource.parentFrame)
    401             resource.parentFrame.removeResource(resource);
     398            resource.parentFrame.remove(resource);
    402399
    403400        this._associateWithResource(resource);
    404401
    405402        if (this._isProvisionalResource(resource)) {
    406             this._provisionalResourceCollection.addResource(resource);
     403            this._provisionalResourceCollection.add(resource);
    407404            this.dispatchEventToListeners(WebInspector.Frame.Event.ProvisionalResourceWasAdded, {resource});
    408405        } else {
    409             this._resourceCollection.addResource(resource);
     406            this._resourceCollection.add(resource);
    410407            this.dispatchEventToListeners(WebInspector.Frame.Event.ResourceWasAdded, {resource});
    411408        }
    … …  
    416413        // This does not remove provisional resources.
    417414
    418         var resource = this._resourceCollection.removeResource(resourceOrURL);
     415        var resource = this._resourceCollection.remove(resourceOrURL);
    419416        if (!resource)
    420417            return;
    … …  
    429426        // This does not remove provisional resources, use clearProvisionalLoad for that.
    430427
    431         var resources = this.resources;
    432         if (!resources.length)
    433             return;
    434 
    435         for (var i = 0; i < resources.length; ++i)
    436             this._disassociateWithResource(resources[i]);
    437 
    438         this._resourceCollection.removeAllResources();
     428        let resources = this._resourceCollection.items;
     429        if (!resources.size)
     430            return;
     431
     432        for (let resource of resources)
     433            this._disassociateWithResource(resource);
     434
     435        this._resourceCollection.clear();
    439436
    440437        this.dispatchEventToListeners(WebInspector.Frame.Event.AllResourcesRemoved);

  • trunk/Source/WebInspectorUI/UserInterface/Models/ResourceCollection.js

    r181769 r208012  
    11/*
    22 * Copyright (C) 2013 Apple Inc. All rights reserved.
     3 * Copyright (C) 2016 Devin Rousso <dcrousso+webkit@gmail.com>. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2425 */
    2526
    26 WebInspector.ResourceCollection = class ResourceCollection extends WebInspector.Object
     27WebInspector.ResourceCollection = class ResourceCollection extends WebInspector.Collection
    2728{
    28     constructor()
     29    constructor(resourceType)
    2930    {
    30         super();
     31        super(WebInspector.ResourceCollection.verifierForType(resourceType));
    3132
    32         this._resources = [];
     33        this._resourceType = resourceType || null;
    3334        this._resourceURLMap = new Map;
    3435        this._resourcesTypeMap = new Map;
    3536    }
    3637
     38    // Static
     39
     40    static verifierForType(type) {
     41        switch (type) {
     42        case WebInspector.Resource.Type.Document:
     43            return WebInspector.ResourceCollection.TypeVerifier.Document;
     44        case WebInspector.Resource.Type.Stylesheet:
     45            return WebInspector.ResourceCollection.TypeVerifier.Stylesheet;
     46        case WebInspector.Resource.Type.Image:
     47            return WebInspector.ResourceCollection.TypeVerifier.Image;
     48        case WebInspector.Resource.Type.Font:
     49            return WebInspector.ResourceCollection.TypeVerifier.Font;
     50        case WebInspector.Resource.Type.Script:
     51            return WebInspector.ResourceCollection.TypeVerifier.Script;
     52        case WebInspector.Resource.Type.XHR:
     53            return WebInspector.ResourceCollection.TypeVerifier.XHR;
     54        case WebInspector.Resource.Type.WebSocket:
     55            return WebInspector.ResourceCollection.TypeVerifier.WebSocket;
     56        case WebInspector.Resource.Type.Other:
     57            return WebInspector.ResourceCollection.TypeVerifier.Other;
     58        default:
     59            return WebInspector.Collection.TypeVerifier.Resource;
     60        }
     61    }
     62
    3763    // Public
    38 
    39     get resources()
    40     {
    41         return this._resources;
    42     }
    4364
    4465    resourceForURL(url)
    … …  
    4768    }
    4869
    49     resourcesWithType(type)
     70    resourceCollectionForType(type)
    5071    {
    51         return this._resourcesTypeMap.get(type) || [];
     72        if (this._resourceType) {
     73            console.assert(type === this._resourceType);
     74            return this;
     75        }
     76
     77        let resourcesCollectionForType = this._resourcesTypeMap.get(type);
     78        if (!resourcesCollectionForType) {
     79            resourcesCollectionForType = new WebInspector.ResourceCollection(type);
     80            this._resourcesTypeMap.set(type, resourcesCollectionForType);
     81        }
     82
     83        return resourcesCollectionForType;
    5284    }
    5385
    54     addResource(resource)
     86    clear()
    5587    {
    56         console.assert(resource instanceof WebInspector.Resource);
    57         if (!(resource instanceof WebInspector.Resource))
    58             return;
     88        super.clear();
    5989
    60         this._associateWithResource(resource);
     90        this._resourceURLMap.clear();
     91
     92        if (!this._resourceType)
     93            this._resourcesTypeMap.clear();
    6194    }
    6295
    63     removeResource(resourceOrURL)
     96    // Protected
     97
     98    itemAdded(item)
    6499    {
    65         console.assert(resourceOrURL);
    66 
    67         if (resourceOrURL instanceof WebInspector.Resource)
    68             var url = resourceOrURL.url;
    69         else
    70             var url = resourceOrURL;
    71 
    72         // Fetch the resource by URL even if we were passed a WebInspector.Resource.
    73         // We do this incase the WebInspector.Resource is a new object that isn't in _resources,
    74         // but the URL is a valid resource.
    75         var resource = this.resourceForURL(url);
    76         console.assert(resource instanceof WebInspector.Resource);
    77         if (!(resource instanceof WebInspector.Resource))
    78             return null;
    79 
    80         this._disassociateWithResource(resource);
    81 
    82         return resource;
     100        this._associateWithResource(item);
    83101    }
    84102
    85     removeAllResources()
     103    itemRemoved(item)
    86104    {
    87         if (!this._resources.length)
    88             return;
     105        this._disassociateWithResource(item);
     106    }
    89107
    90         for (var i = 0; i < this._resources.length; ++i)
    91             this._disassociateWithResource(this._resources[i], true);
     108    itemsCleared(items)
     109    {
     110        const skipRemoval = true;
    92111
    93         this._resources = [];
    94         this._resourceURLMap.clear();
    95         this._resourcesTypeMap.clear();
     112        for (let item of items)
     113            this._disassociateWithResource(item, skipRemoval);
    96114    }
    97115
    … …  
    100118    _associateWithResource(resource)
    101119    {
    102         this._resources.push(resource);
    103120        this._resourceURLMap.set(resource.url, resource);
    104121
    105         if (!this._resourcesTypeMap.has(resource.type))
    106             this._resourcesTypeMap.set(resource.type, [resource]);
    107         else
    108             this._resourcesTypeMap.get(resource.type).push(resource);
     122        if (!this._resourceType) {
     123            let resourcesCollectionForType = this.resourceCollectionForType(resource.type);
     124            resourcesCollectionForType.add(resource);
     125        }
    109126
    110127        resource.addEventListener(WebInspector.Resource.Event.URLDidChange, this._resourceURLDidChange, this);
    … …  
    114131    _disassociateWithResource(resource, skipRemoval)
    115132    {
    116         if (skipRemoval) {
    117             this._resources.remove(resource);
    118             if (this._resourcesTypeMap.has(resource.type))
    119                 this._resourcesTypeMap.get(resource.type).remove(resource);
    120             this._resourceURLMap.delete(resource.url);
     133        resource.removeEventListener(WebInspector.Resource.Event.URLDidChange, this._resourceURLDidChange, this);
     134        resource.removeEventListener(WebInspector.Resource.Event.TypeDidChange, this._resourceTypeDidChange, this);
     135
     136        if (skipRemoval)
     137            return;
     138
     139        if (!this._resourceType) {
     140            let resourcesCollectionForType = this.resourceCollectionForType(resource.type);
     141            resourcesCollectionForType.remove(resource);
    121142        }
    122143
    123         resource.removeEventListener(WebInspector.Resource.Event.URLDidChange, this._resourceURLDidChange, this);
    124         resource.removeEventListener(WebInspector.Resource.Event.TypeDidChange, this._resourceTypeDidChange, this);
     144        this._resourceURLMap.delete(resource.url);
    125145    }
    126146
    127147    _resourceURLDidChange(event)
    128148    {
    129         var resource = event.target;
     149        let resource = event.target;
    130150        console.assert(resource instanceof WebInspector.Resource);
    131151        if (!(resource instanceof WebInspector.Resource))
    132152            return;
    133153
    134         var oldURL = event.data.oldURL;
     154        let oldURL = event.data.oldURL;
    135155        console.assert(oldURL);
    136156        if (!oldURL)
    … …  
    143163    _resourceTypeDidChange(event)
    144164    {
    145         var resource = event.target;
     165        let resource = event.target;
    146166        console.assert(resource instanceof WebInspector.Resource);
    147167        if (!(resource instanceof WebInspector.Resource))
    148168            return;
    149169
    150         var oldType = event.data.oldType;
     170        if (this._resourceType) {
     171            console.assert(resource.type !== this._resourceType);
     172            this.remove(resource);
     173            return;
     174        }
     175
     176        let oldType = event.data.oldType;
    151177        console.assert(oldType);
    152178        if (!oldType)
    153179            return;
    154180
    155         if (!this._resourcesTypeMap.has(resource.type))
    156             this._resourcesTypeMap.set(resource.type, [resource]);
    157         else
    158             this._resourcesTypeMap.get(resource.type).push(resource);
     181        let resourcesWithNewType = this.resourceCollectionForType(resource.type);
     182        resourcesWithNewType.add(resource);
    159183
    160         if (this._resourcesTypeMap.has(oldType))
    161             this._resourcesTypeMap.get(oldType).remove(resource);
     184        let resourcesWithOldType = this.resourceCollectionForType(oldType);
     185        resourcesWithOldType.remove(resource);
    162186    }
    163187};
     188
     189WebInspector.ResourceCollection.TypeVerifier = {
     190    Document: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Document,
     191    Stylesheet: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Stylesheet,
     192    Image: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Image,
     193    Font: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Font,
     194    Script: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Script,
     195    XHR: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.XHR,
     196    WebSocket: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.WebSocket,
     197    Other: (object) => WebInspector.Collection.TypeVerifier.Resource(object) && object.type === WebInspector.Resource.Type.Other,
     198};

  • trunk/Source/WebInspectorUI/UserInterface/Test.html

    r208009 r208012  
    103103    <script src="Models/CallingContextTree.js"></script>
    104104    <script src="Models/CallingContextTreeNode.js"></script>
     105    <script src="Models/Collection.js"></script>
    105106    <script src="Models/CollectionEntry.js"></script>
    106107    <script src="Models/CollectionEntryPreview.js"></script>

  • trunk/Source/WebInspectorUI/UserInterface/Views/CookieStorageContentView.js

    r205425 r208012  
    161161            // The main resource isn't in the list of resources, so add it as a candidate.
    162162            allResources.push(frame.mainResource);
    163             allResources = allResources.concat(frame.resources);
     163            allResources = allResources.concat(frame.resourceCollection.toArray());
    164164        }
    165165

  • trunk/Source/WebInspectorUI/UserInterface/Views/DebuggerSidebarPanel.js

    r207444 r208012  
    420420        this._addResource(frame.mainResource);
    421421
    422         for (var resource of frame.resources)
     422        for (let resource of frame.resourceCollection.items)
    423423            this._addResource(resource);
    424424

  • trunk/Source/WebInspectorUI/UserInterface/Views/FrameTreeElement.js

    r207838 r208012  
    7676        function makeChildCountCallback(frame, resourceType) {
    7777            return function() {
    78                 return frame.resourcesWithType(resourceType).length;
     78                return frame.resourceCollectionForType(resourceType).items.size;
    7979            };
    8080        }
    … …  
    182182            this.addChildForRepresentedObject(this._frame.childFrames[i]);
    183183
    184         for (var i = 0; i < this._frame.resources.length; ++i)
    185             this.addChildForRepresentedObject(this._frame.resources[i]);
     184        for (let resource of this._frame.resourceCollection.items)
     185            this.addChildForRepresentedObject(resource);
    186186
    187187        var sourceMaps = this.resource && this.resource.sourceMaps;

  • trunk/Source/WebInspectorUI/UserInterface/Views/OpenResourceDialog.js

    r205426 r208012  
    269269        while (frames.length) {
    270270            let currentFrame = frames.shift();
    271             let resources = [currentFrame.mainResource].concat(currentFrame.resources);
     271            let resources = [currentFrame.mainResource].concat(Array.from(currentFrame.resourceCollection.items));
    272272            for (let resource of resources)
    273273                this._addResource(resource, suppressFilterUpdate);
Note: See TracChangeset for help on using the changeset viewer.