Changeset 70240 in webkit


Ignore:
Timestamp:
Oct 21, 2010 9:31:35 AM (14 years ago)
Author:
pfeldman@chromium.org
Message:

2010-10-21 Pavel Feldman <​pfeldman@chromium.org>

Reviewed by Yury Semikhatsky.

Web Inspector: provide resource tree in the Storage panel (behind the flag).
​https://bugs.webkit.org/show_bug.cgi?id=48069

  • WebCore.gypi:
  • inspector/Inspector.idl:
  • inspector/InspectorController.cpp: (WebCore::InspectorController::frameDetachedFromParent):
  • inspector/InspectorResourceAgent.cpp: (WebCore::buildObjectForDocumentLoader): (WebCore::buildObjectForFrameResource): (WebCore::buildObjectForCachedResource): (WebCore::populateObjectWithFrameResources): (WebCore::InspectorResourceAgent::identifierForInitialRequest): (WebCore::InspectorResourceAgent::didLoadResourceFromMemoryCache): (WebCore::buildObjectForFrameTree): (WebCore::InspectorResourceAgent::didCommitLoad): (WebCore::InspectorResourceAgent::frameDetachedFromParent): (WebCore::InspectorResourceAgent::cachedResources): (WebCore::InspectorResourceAgent::resourceContent):
  • inspector/InspectorResourceAgent.h:
  • inspector/front-end/Images/frame.png: Added.
  • inspector/front-end/NetworkPanel.js: (WebInspector.NetworkPanel.prototype.refreshResource): (WebInspector.NetworkPanel.prototype._showResource):
  • inspector/front-end/Resource.js: (WebInspector.Resource.Type.toString): (WebInspector.Resource.prototype.getContents):
  • inspector/front-end/ResourceManager.js: (WebInspector.ResourceManager): (WebInspector.ResourceManager.prototype.identifierForInitialRequest): (WebInspector.ResourceManager.prototype._createResource): (WebInspector.ResourceManager.prototype.willSendRequest): (WebInspector.ResourceManager.prototype._appendRedirect): (WebInspector.ResourceManager.prototype.markResourceAsCached): (WebInspector.ResourceManager.prototype.didReceiveResponse): (WebInspector.ResourceManager.prototype._updateResourceWithResponse): (WebInspector.ResourceManager.prototype.didReceiveContentLength): (WebInspector.ResourceManager.prototype.didFinishLoading): (WebInspector.ResourceManager.prototype.didFailLoading): (WebInspector.ResourceManager.prototype.didLoadResourceFromMemoryCache): (WebInspector.ResourceManager.prototype._updateResourceWithCachedResource): (WebInspector.ResourceManager.prototype.setOverrideContent): (WebInspector.ResourceManager.prototype.didCommitLoadForFrame): (WebInspector.ResourceManager.prototype.frameDetachedFromParent): (WebInspector.ResourceManager.prototype._clearResources): (WebInspector.ResourceManager.prototype.didCreateWebSocket): (WebInspector.ResourceManager.prototype.willSendWebSocketHandshakeRequest): (WebInspector.ResourceManager.prototype.didReceiveWebSocketHandshakeResponse): (WebInspector.ResourceManager.prototype.didCloseWebSocket): (WebInspector.ResourceManager.prototype._processCachedResources): (WebInspector.ResourceManager.prototype._appendFramesRecursively.comparator): (WebInspector.ResourceManager.prototype._appendFramesRecursively): (WebInspector.ResourceManager.createResourceView): (WebInspector.ResourceManager.resourceViewTypeMatchesResource): (WebInspector.ResourceManager.resourceViewForResource): (WebInspector.ResourceManager.getContents):
  • inspector/front-end/ResourcesPanel.js: (WebInspector.ResourcesPanel.prototype.get searchableViews): (WebInspector.ResourcesPanel.prototype.addMessageToResource): (WebInspector.ResourcesPanel.prototype._recreateViewForResourceIfNeeded): (WebInspector.ResourcesPanel.prototype.showResource): (WebInspector.ResourcesPanel.prototype.sourceFrameForResource):
  • inspector/front-end/ScriptsPanel.js: (WebInspector.ScriptsPanel.prototype._showScriptOrResource):
  • inspector/front-end/StoragePanel.js: (WebInspector.StoragePanel): (WebInspector.StoragePanel.prototype.addFrame): (WebInspector.StoragePanel.prototype.removeFrame): (WebInspector.StoragePanel.prototype.addFrameResource): (WebInspector.StoragePanel.prototype.removeFrameResources): (WebInspector.StoragePanel.prototype.showResource): (WebInspector.BaseStorageTreeElement.prototype.onattach): (WebInspector.BaseStorageTreeElement.prototype.onreveal): (WebInspector.FrameTreeElement): (WebInspector.FrameTreeElement.prototype.onselect): (WebInspector.FrameResourceTreeElement): (WebInspector.FrameResourceTreeElement.prototype.onselect): (WebInspector.FrameResourceTreeElement.prototype.onattach):
  • inspector/front-end/WebKit.qrc:
  • inspector/front-end/inspector.css: (.frame-storage-tree-item .icon): (.storage.panel .sidebar.outline-disclosure > ol): (.resources-category-images .image-resource-icon-preview): (.children.small .resources-category-images .image-resource-icon-preview):
  • inspector/front-end/inspector.js:
Location:
trunk/WebCore
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r70239 r70240  
     12010-10-21  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Yury Semikhatsky.
     4
     5        Web Inspector: provide resource tree in the Storage panel (behind the flag).
     6        https://bugs.webkit.org/show_bug.cgi?id=48069
     7
     8        * WebCore.gypi:
     9        * inspector/Inspector.idl:
     10        * inspector/InspectorController.cpp:
     11        (WebCore::InspectorController::frameDetachedFromParent):
     12        * inspector/InspectorResourceAgent.cpp:
     13        (WebCore::buildObjectForDocumentLoader):
     14        (WebCore::buildObjectForFrameResource):
     15        (WebCore::buildObjectForCachedResource):
     16        (WebCore::populateObjectWithFrameResources):
     17        (WebCore::InspectorResourceAgent::identifierForInitialRequest):
     18        (WebCore::InspectorResourceAgent::didLoadResourceFromMemoryCache):
     19        (WebCore::buildObjectForFrameTree):
     20        (WebCore::InspectorResourceAgent::didCommitLoad):
     21        (WebCore::InspectorResourceAgent::frameDetachedFromParent):
     22        (WebCore::InspectorResourceAgent::cachedResources):
     23        (WebCore::InspectorResourceAgent::resourceContent):
     24        * inspector/InspectorResourceAgent.h:
     25        * inspector/front-end/Images/frame.png: Added.
     26        * inspector/front-end/NetworkPanel.js:
     27        (WebInspector.NetworkPanel.prototype.refreshResource):
     28        (WebInspector.NetworkPanel.prototype._showResource):
     29        * inspector/front-end/Resource.js:
     30        (WebInspector.Resource.Type.toString):
     31        (WebInspector.Resource.prototype.getContents):
     32        * inspector/front-end/ResourceManager.js:
     33        (WebInspector.ResourceManager):
     34        (WebInspector.ResourceManager.prototype.identifierForInitialRequest):
     35        (WebInspector.ResourceManager.prototype._createResource):
     36        (WebInspector.ResourceManager.prototype.willSendRequest):
     37        (WebInspector.ResourceManager.prototype._appendRedirect):
     38        (WebInspector.ResourceManager.prototype.markResourceAsCached):
     39        (WebInspector.ResourceManager.prototype.didReceiveResponse):
     40        (WebInspector.ResourceManager.prototype._updateResourceWithResponse):
     41        (WebInspector.ResourceManager.prototype.didReceiveContentLength):
     42        (WebInspector.ResourceManager.prototype.didFinishLoading):
     43        (WebInspector.ResourceManager.prototype.didFailLoading):
     44        (WebInspector.ResourceManager.prototype.didLoadResourceFromMemoryCache):
     45        (WebInspector.ResourceManager.prototype._updateResourceWithCachedResource):
     46        (WebInspector.ResourceManager.prototype.setOverrideContent):
     47        (WebInspector.ResourceManager.prototype.didCommitLoadForFrame):
     48        (WebInspector.ResourceManager.prototype.frameDetachedFromParent):
     49        (WebInspector.ResourceManager.prototype._clearResources):
     50        (WebInspector.ResourceManager.prototype.didCreateWebSocket):
     51        (WebInspector.ResourceManager.prototype.willSendWebSocketHandshakeRequest):
     52        (WebInspector.ResourceManager.prototype.didReceiveWebSocketHandshakeResponse):
     53        (WebInspector.ResourceManager.prototype.didCloseWebSocket):
     54        (WebInspector.ResourceManager.prototype._processCachedResources):
     55        (WebInspector.ResourceManager.prototype._appendFramesRecursively.comparator):
     56        (WebInspector.ResourceManager.prototype._appendFramesRecursively):
     57        (WebInspector.ResourceManager.createResourceView):
     58        (WebInspector.ResourceManager.resourceViewTypeMatchesResource):
     59        (WebInspector.ResourceManager.resourceViewForResource):
     60        (WebInspector.ResourceManager.getContents):
     61        * inspector/front-end/ResourcesPanel.js:
     62        (WebInspector.ResourcesPanel.prototype.get searchableViews):
     63        (WebInspector.ResourcesPanel.prototype.addMessageToResource):
     64        (WebInspector.ResourcesPanel.prototype._recreateViewForResourceIfNeeded):
     65        (WebInspector.ResourcesPanel.prototype.showResource):
     66        (WebInspector.ResourcesPanel.prototype.sourceFrameForResource):
     67        * inspector/front-end/ScriptsPanel.js:
     68        (WebInspector.ScriptsPanel.prototype._showScriptOrResource):
     69        * inspector/front-end/StoragePanel.js:
     70        (WebInspector.StoragePanel):
     71        (WebInspector.StoragePanel.prototype.addFrame):
     72        (WebInspector.StoragePanel.prototype.removeFrame):
     73        (WebInspector.StoragePanel.prototype.addFrameResource):
     74        (WebInspector.StoragePanel.prototype.removeFrameResources):
     75        (WebInspector.StoragePanel.prototype.showResource):
     76        (WebInspector.BaseStorageTreeElement.prototype.onattach):
     77        (WebInspector.BaseStorageTreeElement.prototype.onreveal):
     78        (WebInspector.FrameTreeElement):
     79        (WebInspector.FrameTreeElement.prototype.onselect):
     80        (WebInspector.FrameResourceTreeElement):
     81        (WebInspector.FrameResourceTreeElement.prototype.onselect):
     82        (WebInspector.FrameResourceTreeElement.prototype.onattach):
     83        * inspector/front-end/WebKit.qrc:
     84        * inspector/front-end/inspector.css:
     85        (.frame-storage-tree-item .icon):
     86        (.storage.panel .sidebar.outline-disclosure > ol):
     87        (.resources-category-images .image-resource-icon-preview):
     88        (.children.small .resources-category-images .image-resource-icon-preview):
     89        * inspector/front-end/inspector.js:
     90
    1912010-10-21  David Kilzer  <ddkilzer@apple.com>
    292

  • trunk/WebCore/WebCore.gypi

    r70235 r70240  
    45094509            'inspector/front-end/Images/focusButtonGlyph.png',
    45104510            'inspector/front-end/Images/forward.png',
     4511            'inspector/front-end/Images/frame.png',
    45114512            'inspector/front-end/Images/gearButtonGlyph.png',
    45124513            'inspector/front-end/Images/glossyHeader.png',

  • trunk/WebCore/inspector/Inspector.idl

    r70046 r70240  
    113113        [handler=Controller] void stopTimelineProfiler();
    114114
    115         [handler=Resource] void cachedResources(out Array resources);
    116         [handler=Resource] void resourceContent(in unsigned long frameID, in String url, out String content);
    117         [notify] void identifierForInitialRequest(out long identifier, out String url, out unsigned long frameID, out boolean isMainResource);
     115        [handler=Resource] void cachedResources(out Object resources);
     116        [handler=Resource] void resourceContent(in unsigned long frameId, in String url, out String content);
     117        [notify] void identifierForInitialRequest(out long identifier, out String url, out Object loader, out boolean isMainResource);
    118118        [notify] void willSendRequest(out long identifier, out double time, out Object request, out Object redirectResponse);
    119119        [notify] void markResourceAsCached(out long identifier);
    … …  
    122122        [notify] void didFinishLoading(out long identifier, out double finishTime);
    123123        [notify] void didFailLoading(out long identifier, out double time, out String localizedDescription);
    124         [notify] void didLoadResourceFromMemoryCache(out double time, out unsigned long frameID, out Object resource);
     124        [notify] void didLoadResourceFromMemoryCache(out double time, out Object resource);
    125125        [notify] void setOverrideContent(out long identifier, out String sourceString, out String type);
    126         [notify] void didCommitLoad(out unsigned long frameID);
    127         [notify] void frameDetachedFromParent(out unsigned long frameID);
     126        [notify] void didCommitLoadForFrame(out Object frameTree, out unsigned long loaderId);
     127        [notify] void frameDetachedFromParent(out Object frameTree);
    128128
    129129        [notify] void didCreateWebSocket(out unsigned long identifier, out String requestURL);

  • trunk/WebCore/inspector/InspectorController.cpp

    r70235 r70240  
    827827}
    828828
    829 void InspectorController::frameDetachedFromParent(Frame* frame)
     829void InspectorController::frameDetachedFromParent(Frame* rootFrame)
    830830{
    831831    if (!enabled())
    … …  
    833833
    834834    if (m_resourceAgent)
    835         m_resourceAgent->frameDetachedFromParent(frame);
    836 
    837     if (ResourcesMap* resourceMap = m_frameResources.get(frame))
    838         removeAllResources(resourceMap);
     835        m_resourceAgent->frameDetachedFromParent(rootFrame);
     836
     837    for (Frame* frame = rootFrame; frame; frame = frame->tree()->traverseNext(rootFrame))
     838        if (ResourcesMap* resourceMap = m_frameResources.get(frame))
     839            removeAllResources(resourceMap);
    839840}
    840841

  • trunk/WebCore/inspector/InspectorResourceAgent.cpp

    r69949 r70240  
    200200}
    201201
    202 static PassRefPtr<InspectorObject> buildObjectForMainResource(Frame* frame)
     202static PassRefPtr<InspectorObject> buildObjectForDocumentLoader(DocumentLoader* loader)
     203{
     204    RefPtr<InspectorObject> documentLoaderObject = InspectorObject::create();
     205    documentLoaderObject->setNumber("frameId", reinterpret_cast<uintptr_t>(loader->frame()));
     206    documentLoaderObject->setNumber("loaderId", reinterpret_cast<uintptr_t>(loader));
     207    return documentLoaderObject;
     208}
     209
     210static PassRefPtr<InspectorObject> buildObjectForFrameResource(Frame* frame)
    203211{
    204212    FrameLoader* frameLoader = frame->loader();
    … …  
    207215    RefPtr<InspectorObject> resourceObject = InspectorObject::create();
    208216    resourceObject->setString("url", loader->url().string());
    209     resourceObject->setString("host", loader->url().host());
    210     resourceObject->setString("path", loader->url().path());
    211     resourceObject->setString("lastPathComponent", loader->url().lastPathComponent());
    212     resourceObject->setString("type", "Document");
     217    resourceObject->setObject("loader", buildObjectForDocumentLoader(loader));
    213218    resourceObject->setObject("request", buildObjectForResourceRequest(loader->request()));
    214219    resourceObject->setObject("response", buildObjectForResourceResponse(loader->response()));
    … …  
    237242}
    238243
    239 static PassRefPtr<InspectorObject> buildObjectForCachedResource(const CachedResource& cachedResource)
     244static PassRefPtr<InspectorObject> buildObjectForCachedResource(DocumentLoader* loader, const CachedResource& cachedResource)
    240245{
    241246    RefPtr<InspectorObject> resourceObject = InspectorObject::create();
    … …  
    244249    resourceObject->setNumber("encodedSize", cachedResource.encodedSize());
    245250    resourceObject->setObject("response", buildObjectForResourceResponse(cachedResource.response()));
     251    resourceObject->setObject("loader", buildObjectForDocumentLoader(loader));
    246252    return resourceObject;
    247253}
    248254
    249 static PassRefPtr<InspectorObject> buildObjectForFrameResources(Frame* frame)
    250 {
    251     RefPtr<InspectorObject> frameResources = InspectorObject::create();
    252     frameResources->setNumber("frameID", reinterpret_cast<uintptr_t>(frame));
    253     frameResources->setObject("mainResource", buildObjectForMainResource(frame));
     255static void populateObjectWithFrameResources(Frame* frame, PassRefPtr<InspectorObject> frameResources)
     256{
     257    frameResources->setObject("resource", buildObjectForFrameResource(frame));
    254258    RefPtr<InspectorArray> subresources = InspectorArray::create();
    255259    frameResources->setArray("subresources", subresources);
    … …  
    259263    for (CachedResourceLoader::DocumentResourceMap::const_iterator it = allResources.begin(); it != end; ++it) {
    260264        CachedResource* cachedResource = it->second.get();
    261         if (cachedResource)
    262             subresources->pushValue(buildObjectForCachedResource(*cachedResource));
    263     }
    264     return frameResources;
     265        if (cachedResource) {
     266            RefPtr<InspectorObject> cachedResourceObject = buildObjectForCachedResource(frame->loader()->documentLoader(), *cachedResource);
     267            subresources->pushValue(cachedResourceObject);
     268        }
     269    }
    265270}
    266271
    … …  
    271276void InspectorResourceAgent::identifierForInitialRequest(unsigned long identifier, const KURL& url, DocumentLoader* loader, bool isMainResource)
    272277{
    273     m_frontend->identifierForInitialRequest(identifier, url.string(), reinterpret_cast<uintptr_t>(loader->frame()), isMainResource);
     278    RefPtr<InspectorObject> loaderObject = buildObjectForDocumentLoader(loader);
     279    m_frontend->identifierForInitialRequest(identifier, url.string(), loaderObject, isMainResource);
    274280}
    275281
    … …  
    322328void InspectorResourceAgent::didLoadResourceFromMemoryCache(DocumentLoader* loader, const CachedResource* resource)
    323329{
    324     Frame* frame = loader->frame();
    325     m_frontend->didLoadResourceFromMemoryCache(currentTime(), reinterpret_cast<uintptr_t>(frame), buildObjectForCachedResource(*resource));
     330    m_frontend->didLoadResourceFromMemoryCache(currentTime(), buildObjectForCachedResource(loader, *resource));
    326331}
    327332
    … …  
    343348}
    344349
     350static PassRefPtr<InspectorObject> buildObjectForFrameTree(Frame* frame, bool dumpResources)
     351{
     352    RefPtr<InspectorObject> frameObject = InspectorObject::create();
     353    frameObject->setNumber("id", reinterpret_cast<uintptr_t>(frame));
     354    if (dumpResources)
     355        populateObjectWithFrameResources(frame, frameObject);
     356    RefPtr<InspectorArray> childrenArray;
     357    for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
     358        if (!childrenArray) {
     359            childrenArray = InspectorArray::create();
     360            frameObject->setArray("children", childrenArray);
     361        }
     362        childrenArray->pushObject(buildObjectForFrameTree(child, dumpResources));
     363    }
     364    return frameObject;
     365}
     366
    345367void InspectorResourceAgent::didCommitLoad(DocumentLoader* loader)
    346368{
    347     Frame* frame = loader->frame();
    348     m_frontend->didCommitLoad(reinterpret_cast<uintptr_t>(frame));
     369    RefPtr<InspectorObject> frameObject = buildObjectForFrameTree(loader->frame(), false);
     370    m_frontend->didCommitLoadForFrame(frameObject, reinterpret_cast<uintptr_t>(loader));
    349371}
    350372
    351373void InspectorResourceAgent::frameDetachedFromParent(Frame* frame)
    352374{
    353     m_frontend->frameDetachedFromParent(reinterpret_cast<uintptr_t>(frame));
    354 }
    355 
     375    RefPtr<InspectorObject> frameObject = buildObjectForFrameTree(frame, false);
     376    m_frontend->frameDetachedFromParent(frameObject);
     377}
    356378
    357379#if ENABLE(WEB_SOCKETS)
    … …  
    405427#endif // ENABLE(WEB_SOCKETS)
    406428
    407 void InspectorResourceAgent::cachedResources(RefPtr<InspectorArray>* resources)
    408 {
    409     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext(m_page->mainFrame()))
    410         (*resources)->pushObject(buildObjectForFrameResources(frame));
    411 }
    412 
    413 void InspectorResourceAgent::resourceContent(unsigned long frameID, const String& url, String* content)
     429void InspectorResourceAgent::cachedResources(RefPtr<InspectorObject>* object)
     430{
     431    *object = buildObjectForFrameTree(m_page->mainFrame(), true);
     432}
     433
     434void InspectorResourceAgent::resourceContent(unsigned long frameId, const String& url, String* content)
    414435{
    415436    RefPtr<InspectorArray> frameResources = InspectorArray::create();
    416437    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext(m_page->mainFrame())) {
    417         if (reinterpret_cast<uintptr_t>(frame) != frameID)
     438        if (reinterpret_cast<uintptr_t>(frame) != frameId)
    418439            continue;
    419440        InspectorResourceAgent::resourceContent(frame, KURL(ParsedURLString, url), content);

  • trunk/WebCore/inspector/InspectorResourceAgent.h

    r69948 r70240  
    9898
    9999    // Called from frontend
    100     void cachedResources(RefPtr<InspectorArray>*);
     100    void cachedResources(RefPtr<InspectorObject>*);
    101101    void resourceContent(unsigned long frameID, const String& url, String* content);
    102102

  • trunk/WebCore/inspector/front-end/NetworkPanel.js

    r69948 r70240  
    788788            return;
    789789
    790         if (this._resourceViewTypeMatchesResource(resource, resource._resourcesView))
    791             return;
    792 
    793         var newView = this._createResourceView(resource);
    794         if (newView.__proto__ === resource._resourcesView.__proto__)
    795             return;
     790        if (WebInspector.ResourceManager.resourceViewTypeMatchesResource(resource, resource._resourcesView))
     791            return;
     792        var newView = WebInspector.ResourceManager.createResourceView(resource);
    796793
    797794        var oldView = resource._resourcesView;
    … …  
    832829            this.visibleResource._resourcesView.hide();
    833830
    834         var view = this._resourceViewForResource(resource);
     831        var view = WebInspector.ResourceManager.resourceViewForResource(resource);
    835832        view.headersVisible = true;
    836833        view.show(this._viewsContainerElement);
    … …  
    860857
    861858        this.updateSidebarWidth();
    862     },
    863 
    864     _resourceViewForResource: function(resource)
    865     {
    866         if (!resource)
    867             return null;
    868         if (!resource._resourcesView)
    869             resource._resourcesView = this._createResourceView(resource);
    870         return resource._resourcesView;
    871859    },
    872860
    … …  
    889877            this._timelineGrid.element.removeStyleClass("small");
    890878        }
    891     },
    892 
    893     _createResourceView: function(resource)
    894     {
    895         switch (resource.category) {
    896             case WebInspector.resourceCategories.documents:
    897             case WebInspector.resourceCategories.stylesheets:
    898             case WebInspector.resourceCategories.scripts:
    899             case WebInspector.resourceCategories.xhr:
    900                 return new WebInspector.SourceView(resource);
    901             case WebInspector.resourceCategories.images:
    902                 return new WebInspector.ImageView(resource);
    903             case WebInspector.resourceCategories.fonts:
    904                 return new WebInspector.FontView(resource);
    905             default:
    906                 return new WebInspector.ResourceView(resource);
    907         }
    908     },
    909 
    910     _resourceViewTypeMatchesResource: function(resource, resourceView)
    911     {
    912         switch (resource.category) {
    913             case WebInspector.resourceCategories.documents:
    914             case WebInspector.resourceCategories.stylesheets:
    915             case WebInspector.resourceCategories.scripts:
    916             case WebInspector.resourceCategories.xhr:
    917                 return resourceView instanceof WebInspector.SourceView;
    918             case WebInspector.resourceCategories.images:
    919                 return resourceView instanceof WebInspector.ImageView;
    920             case WebInspector.resourceCategories.fonts:
    921                 return resourceView instanceof WebInspector.FontView;
    922             default:
    923                 return resourceView instanceof WebInspector.ResourceView;
    924         }
    925         return false;
    926879    },
    927880

  • trunk/WebCore/inspector/front-end/Resource.js

    r70137 r70240  
    7575                return "script";
    7676            case this.XHR:
    77                 return "XHR";
     77                return "xhr";
    7878            case this.Media:
    7979                return "media";
    8080            case this.WebSocket:
    81                 return "WebSocket";
     81                return "websocket";
    8282            case this.Other:
    8383            default:
    … …  
    594594    getContents: function(callback)
    595595    {
    596         // FIXME: eventually, cached resources will have no identifiers.
    597         if (this.frameID)
    598             InspectorBackend.resourceContent(this.frameID, this.url, callback);
    599         else
    600             InspectorBackend.getResourceContent(this.identifier, false, callback);
     596        WebInspector.ResourceManager.getContents(this, callback);
    601597    }
    602598}

  • trunk/WebCore/inspector/front-end/ResourceManager.js

    r69948 r70240  
    4141        "didLoadResourceFromMemoryCache",
    4242        "setOverrideContent",
    43         "didCommitLoad",
     43        "didCommitLoadForFrame",
    4444        "frameDetachedFromParent",
    4545        "didCreateWebSocket",
    … …  
    4848        "didCloseWebSocket");
    4949
    50     this._resources = {};
     50    this._resourcesById = {};
    5151    this._resourcesByFrame = {};
    5252    this._lastCachedId = 0;
     53    InspectorBackend.cachedResources(this._processCachedResources.bind(this));
    5354}
    5455
    … …  
    6061    },
    6162
    62     identifierForInitialRequest: function(identifier, url, frameID, isMainResource)
    63     {
    64         var resource = new WebInspector.Resource(identifier, url);
     63    identifierForInitialRequest: function(identifier, url, loader, isMainResource)
     64    {
     65        var resource = this._createResource(identifier, url, loader);
    6566        if (isMainResource)
    6667            resource.isMainResource = true;
    67         this._resources[identifier] = resource;
    68 
    69         if (frameID) {
    70             resource.frameID = frameID;
    71             var resourcesForFrame = this._resourcesByFrame[frameID];
    72             if (!resourcesForFrame) {
    73                 resourcesForFrame = [];
    74                 this._resourcesByFrame[frameID] = resourcesForFrame;
    75             }
    76             resourcesForFrame.push(resource);
    77         }
    78 
    79         if (WebInspector.panels.network)
    80             WebInspector.panels.network.addResource(resource);
     68
     69        WebInspector.panels.network.addResource(resource);
     70    },
     71
     72    _createResource: function(identifier, url, loader)
     73    {
     74        var resource = new WebInspector.Resource(identifier, url);
     75        this._resourcesById[identifier] = resource;
     76
     77        resource.loader = loader;
     78        var resourcesForFrame = this._resourcesByFrame[loader.frameId];
     79        if (!resourcesForFrame) {
     80            resourcesForFrame = {};
     81            this._resourcesByFrame[loader.frameId] = resourcesForFrame;
     82        }
     83        resourcesForFrame[resource.identifier] = resource;
     84        return resource;
    8185    },
    8286
    8387    willSendRequest: function(identifier, time, request, redirectResponse)
    8488    {
    85         var resource = this._resources[identifier];
     89        var resource = this._resourcesById[identifier];
    8690        if (!resource)
    8791            return;
    … …  
    8993        // Redirect may have empty URL and we'd like to not crash with invalid HashMap entry.
    9094        // See http/tests/misc/will-send-request-returns-null-on-redirect.html
    91         if (!redirectResponse.isNull && request.url.length) {
     95        var isRedirect = !redirectResponse.isNull && request.url.length;
     96        if (isRedirect) {
    9297            resource.endTime = time;
    9398            this.didReceiveResponse(identifier, time, "Other", redirectResponse);
    … …  
    100105        resource.startTime = time;
    101106
    102         if (WebInspector.panels.network)
     107        if (isRedirect)
     108            WebInspector.panels.network.addResource(resource);
     109        else
    103110            WebInspector.panels.network.refreshResource(resource);
    104111    },
    … …  
    108115        // We always store last redirect by the original id key. Rest of the redirects are referenced from within the last one.
    109116
    110         var originalResource = this._resources[identifier];
     117        var originalResource = this._resourcesById[identifier];
    111118        var redirectIdentifier = originalResource.identifier + ":" + (originalResource.redirects ? originalResource.redirects.length : 0);
    112119        originalResource.identifier = redirectIdentifier;
    113         this._resources[redirectIdentifier] = originalResource;
    114 
    115         this.identifierForInitialRequest(identifier, redirectURL, originalResource.frameID);
    116 
    117         var newResource = this._resources[identifier];
     120        this._resourcesById[redirectIdentifier] = originalResource;
     121
     122        var newResource = this._createResource(identifier, redirectURL, originalResource.loader);
    118123        newResource.redirects = originalResource.redirects || [];
    119124        delete originalResource.redirects;
    … …  
    124129    markResourceAsCached: function(identifier)
    125130    {
    126         var resource = this._resources[identifier];
     131        var resource = this._resourcesById[identifier];
    127132        if (!resource)
    128133            return;
    129134
    130135        resource.cached = true;
    131 
    132         if (WebInspector.panels.network)
    133             WebInspector.panels.network.refreshResource(resource);
     136        WebInspector.panels.network.refreshResource(resource);
    134137    },
    135138
    136139    didReceiveResponse: function(identifier, time, resourceType, response)
    137140    {
    138         var resource = this._resources[identifier];
    139         if (!resource)
    140             return;
    141 
     141        var resource = this._resourcesById[identifier];
     142        if (!resource)
     143            return;
     144        this._updateResourceWithResponse(resource, response);
    142145        resource.type = WebInspector.Resource.Type[resourceType];
     146        resource.responseReceivedTime = time;
     147
     148        WebInspector.panels.network.refreshResource(resource);
     149    },
     150
     151    _updateResourceWithResponse: function(resource, response)
     152    {
    143153        resource.mimeType = response.mimeType;
    144154        resource.expectedContentLength = response.expectedContentLength;
    … …  
    151161        resource.connectionReused = response.connectionReused;
    152162        resource.connectionID = response.connectionID;
    153         resource.responseReceivedTime = time;
    154163
    155164        if (response.wasCached)
    … …  
    162171            resource.responseHeaders = response.rawHeaders.responseHeaders;
    163172        }
    164 
    165         if (WebInspector.panels.network)
    166             WebInspector.panels.network.refreshResource(resource);
    167173    },
    168174
    169175    didReceiveContentLength: function(identifier, time, lengthReceived)
    170176    {
    171         var resource = this._resources[identifier];
     177        var resource = this._resourcesById[identifier];
    172178        if (!resource)
    173179            return;
    … …  
    176182        resource.endTime = time;
    177183
    178         if (WebInspector.panels.network)
    179             WebInspector.panels.network.refreshResource(resource);
     184        WebInspector.panels.network.refreshResource(resource);
    180185    },
    181186
    182187    didFinishLoading: function(identifier, finishTime)
    183188    {
    184         var resource = this._resources[identifier];
     189        var resource = this._resourcesById[identifier];
    185190        if (!resource)
    186191            return;
    … …  
    189194        resource.endTime = finishTime;
    190195
    191         if (WebInspector.panels.network)
    192             WebInspector.panels.network.refreshResource(resource);
     196        WebInspector.panels.network.refreshResource(resource);
    193197    },
    194198
    195199    didFailLoading: function(identifier, time, localizedDescription)
    196200    {
    197         var resource = this._resources[identifier];
     201        var resource = this._resourcesById[identifier];
    198202        if (!resource)
    199203            return;
    … …  
    202206        resource.endTime = time;
    203207
    204         if (WebInspector.panels.network)
    205             WebInspector.panels.network.refreshResource(resource);
    206     },
    207 
    208     didLoadResourceFromMemoryCache: function(time, frameID, cachedResource)
     208        WebInspector.panels.network.refreshResource(resource);
     209    },
     210
     211    didLoadResourceFromMemoryCache: function(time, cachedResource)
    209212    {
    210213        var identifier = "cached:" + this._lastCachedId++;
    211         this.identifierForInitialRequest(identifier, cachedResource.url, frameID);
    212 
    213         var resource = this._resources[identifier];
     214        var resource = this._createResource(identifier, cachedResource.url, cachedResource.loader);
     215        this._updateResourceWithCachedResource(resource, cachedResource);
    214216        resource.cached = true;
    215         resource.startTime = resource.responseReceivedTime = time;
    216         resource.resourceSize = cachedResource.encodedSize();
    217 
    218         this.didReceiveResponse(identifier, time, cachedResource.response);
     217        resource.startTime = resource.responseReceivedTime = resource.endTime = time;
     218
     219        WebInspector.panels.network.addResource(resource);
     220    },
     221
     222    _updateResourceWithCachedResource: function(resource, cachedResource)
     223    {
     224        resource.type = WebInspector.Resource.Type[cachedResource.type];
     225        resource.resourceSize = cachedResource.encodedSize;
     226        this._updateResourceWithResponse(resource, cachedResource.response);
    219227    },
    220228
    221229    setOverrideContent: function(identifier, sourceString, type)
    222230    {
    223         var resource = this._resources[identifier];
     231        var resource = this._resourcesById[identifier];
    224232        if (!resource)
    225233            return;
    … …  
    228236        resource.overridenContent = sourceString;
    229237
    230         if (WebInspector.panels.network)
    231             WebInspector.panels.network.addResource(resource);
    232     },
    233 
    234     didCommitLoad: function(frameID)
    235     {
    236     },
    237 
    238     frameDetachedFromParent: function(frameID)
    239     {
    240         var resourcesForFrame = this._resourcesByFrame[frameID];
    241         for (var i = 0; resourcesForFrame && i < resourcesForFrame.length; ++i)
    242             delete this._resources[resourcesForFrame[i].identifier];
    243         delete this._resourcesByFrame[frameID];
     238        WebInspector.panels.network.addResource(resource);
     239    },
     240
     241    didCommitLoadForFrame: function(frameTree, loaderId)
     242    {
     243        this._clearResources(frameTree.id, loaderId);
     244        for (var i = 0; frameTree.children && frameTree.children.length; ++i)
     245            this.didCommitLoadForFrame(frameTree.children[i], loaderId);
     246    },
     247
     248    frameDetachedFromParent: function(frameTree)
     249    {
     250        this.didCommitLoadForFrame(frameTree, 0);
     251    },
     252
     253    _clearResources: function(frameId, loaderToPreserveId)
     254    {
     255        var resourcesForFrame = this._resourcesByFrame[frameId];
     256        if (resourcesForFrame)
     257            return;
     258
     259        for (var id in resourcesForFrame) {
     260            var resource = this._resourcesById[id];
     261            if (resource.loaderId === loaderToPreserveId)
     262                continue;
     263            delete this._resourcesById[id];
     264            delete resourcesForFrame[id];
     265        }
     266        if (!Object.keys(resourcesForFrame).length)
     267            delete this._resourcesByFrame[frameId];
    244268    },
    245269
    … …  
    247271    {
    248272        this.identifierForInitialRequest(identifier, requestURL);
    249         var resource = this._resources[identifier];
     273        var resource = this._resourcesById[identifier];
    250274        resource.type = WebInspector.Resource.Type.WebSocket;
    251275
    252         if (WebInspector.panels.network)
    253             WebInspector.panels.network.addResource(resource);
     276        WebInspector.panels.network.addResource(resource);
    254277    },
    255278
    256279    willSendWebSocketHandshakeRequest: function(identifier, time, request)
    257280    {
    258         var resource = this._resources[identifier];
     281        var resource = this._resourcesById[identifier];
    259282        if (!resource)
    260283            return;
    … …  
    265288        resource.startTime = time;
    266289
    267         if (WebInspector.panels.network)
    268             WebInspector.panels.network.refreshResource(resource);
     290        WebInspector.panels.network.refreshResource(resource);
    269291    },
    270292
    271293    didReceiveWebSocketHandshakeResponse: function(identifier, time, response)
    272294    {
    273         var resource = this._resources[identifier];
     295        var resource = this._resourcesById[identifier];
    274296        if (!resource)
    275297            return;
    … …  
    281303        resource.responseReceivedTime = time;
    282304
    283         if (WebInspector.panels.network)
    284             WebInspector.panels.network.refreshResource(resource);
     305        WebInspector.panels.network.refreshResource(resource);
    285306    },
    286307
    287308    didCloseWebSocket: function(identifier, time)
    288309    {
    289         var resource = this._resources[identifier];
     310        var resource = this._resourcesById[identifier];
    290311        if (!resource)
    291312            return;
    292313        resource.endTime = time;
    293314
    294         if (WebInspector.panels.network)
    295             WebInspector.panels.network.refreshResource(resource);
     315        WebInspector.panels.network.refreshResource(resource);
     316    },
     317
     318    _processCachedResources: function(mainFramePayload)
     319    {
     320        this._appendFramesRecursively(null, mainFramePayload);
     321    },
     322
     323    _appendFramesRecursively: function(parentFrameId, framePayload)
     324    {
     325        var frameResource = this._createResource(null, framePayload.resource.url, framePayload.resource.loader);
     326        frameResource.type = WebInspector.Resource.Type["Document"];
     327        WebInspector.panels.storage.addFrame(parentFrameId, framePayload.id, frameResource);
     328
     329        for (var i = 0; framePayload.children && i < framePayload.children.length; ++i)
     330            this._appendFramesRecursively(framePayload.id, framePayload.children[i]);
     331
     332        if (!framePayload.subresources)
     333            return;
     334
     335        var resources = [];
     336        for (var i = 0; i < framePayload.subresources.length; ++i) {
     337            var cachedResource = framePayload.subresources[i];
     338            var resource = this._createResource(null, cachedResource.url, cachedResource.loader);
     339            this._updateResourceWithCachedResource(resource, cachedResource);
     340            resources.push(resource);
     341        }
     342
     343        function comparator(a, b)
     344        {
     345            return a.displayName.localeCompare(b.displayName);
     346        }
     347        resources.sort(comparator);
     348
     349        for (var i = 0; i < resources.length; ++i)
     350            WebInspector.panels.storage.addFrameResource(framePayload.id, resources[i]);
    296351    }
    297352}
     353
     354WebInspector.ResourceManager.createResourceView = function(resource)
     355{
     356    switch (resource.category) {
     357    case WebInspector.resourceCategories.documents:
     358    case WebInspector.resourceCategories.stylesheets:
     359    case WebInspector.resourceCategories.scripts:
     360    case WebInspector.resourceCategories.xhr:
     361        return new WebInspector.SourceView(resource);
     362    case WebInspector.resourceCategories.images:
     363        return new WebInspector.ImageView(resource);
     364    case WebInspector.resourceCategories.fonts:
     365        return new WebInspector.FontView(resource);
     366    default:
     367        return new WebInspector.ResourceView(resource);
     368    }
     369}
     370
     371WebInspector.ResourceManager.resourceViewTypeMatchesResource = function(resource, resourceView)
     372{
     373    switch (resource.category) {
     374    case WebInspector.resourceCategories.documents:
     375    case WebInspector.resourceCategories.stylesheets:
     376    case WebInspector.resourceCategories.scripts:
     377    case WebInspector.resourceCategories.xhr:
     378        return resourceView.__proto__ === WebInspector.SourceView.prototype;
     379    case WebInspector.resourceCategories.images:
     380        return resourceView.__proto__ === WebInspector.ImageView.prototype;
     381    case WebInspector.resourceCategories.fonts:
     382        return resourceView.__proto__ === WebInspector.FontView.prototype;
     383    default:
     384        return resourceView.__proto__ === WebInspector.ResourceView.prototype;
     385    }
     386}
     387
     388WebInspector.ResourceManager.resourceViewForResource = function(resource)
     389{
     390    if (!resource)
     391        return null;
     392    if (!resource._resourcesView)
     393        resource._resourcesView = WebInspector.ResourceManager.createResourceView(resource);
     394    return resource._resourcesView;
     395}
     396
     397WebInspector.ResourceManager.getContents = function(resource, callback)
     398{
     399    // FIXME: eventually, cached resources will have no identifiers.
     400    if (resource.loader)
     401        InspectorBackend.resourceContent(resource.loader.frameId, resource.url, callback);
     402    else
     403        InspectorBackend.getResourceContent(resource.identifier, false, callback);
     404}

  • trunk/WebCore/inspector/front-end/ResourcesPanel.js

    r70102 r70240  
    558558            if (!resource._itemsTreeElement || !resource._itemsTreeElement.selectable)
    559559                continue;
    560             var resourceView = this.resourceViewForResource(resource);
     560            var resourceView = WebInspector.ResourceManager.resourceViewForResource(resource);
    561561            if (!resourceView.performSearch || resourceView === visibleView)
    562562                continue;
    … …  
    790790            resource._itemsTreeElement.updateErrorsAndWarnings();
    791791
    792         var view = this.resourceViewForResource(resource);
     792        var view = WebInspector.ResourceManager.resourceViewForResource(resource);
    793793        if (view.addMessage)
    794794            view.addMessage(msg);
    … …  
    824824            return;
    825825
    826         if (this._resourceViewIsConsistentWithCategory(resource, resource._resourcesView))
     826        if (WebInspector.ResourceManager.resourceViewTypeMatchesResource(resource, resource._resourcesView))
    827827            return;
    828 
    829         var newView = this._createResourceView(resource);
     828        var newView = WebInspector.ResourceManager.createResourceView(resource);
     829
    830830        if (!this.currentQuery && resource._itemsTreeElement)
    831831            resource._itemsTreeElement.updateErrorsAndWarnings();
    … …  
    869869            this.visibleResource._resourcesView.hide();
    870870
    871         var view = this.resourceViewForResource(resource);
     871        var view = WebInspector.ResourceManager.resourceViewForResource(resource);
    872872        view.headersVisible = true;
    873873        view.show(this.viewsContainerElement);
    … …  
    910910    },
    911911
    912     resourceViewForResource: function(resource)
    913     {
    914         if (!resource)
    915             return null;
    916         if (!resource._resourcesView)
    917             resource._resourcesView = this._createResourceView(resource);
    918         return resource._resourcesView;
    919     },
    920 
    921912    sourceFrameForResource: function(resource)
    922913    {
    923         var view = this.resourceViewForResource(resource);
     914        var view = WebInspector.ResourceManager.resourceViewForResource(resource);
    924915        if (!view)
    925916            return null;
    … …  
    10671058        this.sortingFunction = selectedOption.sortingFunction;
    10681059        this.calculator = this.summaryBar.calculator = selectedOption.calculator;
    1069     },
    1070 
    1071     _resourceViewIsConsistentWithCategory: function(resource, resourceView)
    1072     {
    1073         switch (resource.category) {
    1074             case WebInspector.resourceCategories.documents:
    1075             case WebInspector.resourceCategories.stylesheets:
    1076             case WebInspector.resourceCategories.scripts:
    1077             case WebInspector.resourceCategories.xhr:
    1078                 return resourceView.__proto__ === WebInspector.SourceView.prototype;
    1079             case WebInspector.resourceCategories.images:
    1080                 return resourceView.__proto__ === WebInspector.ImageView.prototype;
    1081             case WebInspector.resourceCategories.fonts:
    1082                 return resourceView.__proto__ === WebInspector.FontView.prototype;
    1083             default:
    1084                 return resourceView.__proto__ === WebInspector.ResourceView.prototype;
    1085         }
    1086     },
    1087 
    1088     _createResourceView: function(resource)
    1089     {
    1090         switch (resource.category) {
    1091             case WebInspector.resourceCategories.documents:
    1092             case WebInspector.resourceCategories.stylesheets:
    1093             case WebInspector.resourceCategories.scripts:
    1094             case WebInspector.resourceCategories.xhr:
    1095                 return new WebInspector.SourceView(resource);
    1096             case WebInspector.resourceCategories.images:
    1097                 return new WebInspector.ImageView(resource);
    1098             case WebInspector.resourceCategories.fonts:
    1099                 return new WebInspector.FontView(resource);
    1100             default:
    1101                 return new WebInspector.ResourceView(resource);
    1102         }
    11031060    },
    11041061

  • trunk/WebCore/inspector/front-end/ScriptsPanel.js

    r70054 r70240  
    588588            if (!WebInspector.panels.resources)
    589589                return null;
    590             view = WebInspector.panels.resources.resourceViewForResource(scriptOrResource);
     590            view = WebInspector.ResourceManager.resourceViewForResource(scriptOrResource);
    591591            view.headersVisible = false;
    592592        } else if (scriptOrResource instanceof WebInspector.Script)

  • trunk/WebCore/inspector/front-end/StoragePanel.js

    r70214 r70240  
    3535    this.sidebarElement.addStyleClass("outline-disclosure filter-all children small");
    3636
     37    if (Preferences.networkPanelEnabled) {
     38        this.resourcesListTreeElement = new WebInspector.StorageCategoryTreeElement(this, WebInspector.UIString("Resources"), "frame-storage-tree-item");
     39        this.sidebarTree.appendChild(this.resourcesListTreeElement);
     40        this.resourcesListTreeElement.expand();
     41        this._treeElementForFrameId = {};
     42    }
     43
    3744    this.databasesListTreeElement = new WebInspector.StorageCategoryTreeElement(this, WebInspector.UIString("Databases"), "database-storage-tree-item");
    3845    this.sidebarTree.appendChild(this.databasesListTreeElement);
    … …  
    111118        if (this.sidebarTree.selectedTreeElement)
    112119            this.sidebarTree.selectedTreeElement.deselect();
     120    },
     121
     122    addFrame: function(parentFrameId, frameId, frameResource)
     123    {
     124        var parentTreeElement = parentFrameId ? this._treeElementForFrameId[parentFrameId] : this.resourcesListTreeElement;
     125        if (!parentTreeElement) {
     126            console.error("No frame with id:" + parentFrameId + " to route " + displayName + " to.")
     127            return;
     128        }
     129
     130        var frameTreeElement = new WebInspector.FrameTreeElement(this, frameId, frameResource);
     131        this._treeElementForFrameId[frameId] = frameTreeElement;
     132        parentTreeElement.appendChild(frameTreeElement);
     133    },
     134
     135    removeFrame: function(frameId)
     136    {
     137        var frameTreeElement = this._treeElementForFrameId[frameId];
     138        if (!frameTreeElement) {
     139            console.error("No frame with id:" + frameId + " to remove.");
     140            return;
     141        }
     142
     143        delete this._treeElementForFrameId[frameId];
     144        frameTreeElement.parent.removeChild(frameTreeElement);
     145    },
     146
     147    addFrameResource: function(frameId, resource)
     148    {
     149        var frameTreeElement = this._treeElementForFrameId[frameId];
     150        if (!frameTreeElement) {
     151            console.error("No frame with id:" + frameId + " to add resource to.");
     152            return;
     153        }
     154
     155        var resourceTreeElement = new WebInspector.FrameResourceTreeElement(this, resource);
     156        frameTreeElement.appendChild(resourceTreeElement);
     157    },
     158
     159    removeFrameResources: function(frameId)
     160    {
     161        var frameTreeElement = this._treeElementForFrameId[frameId];
     162        if (!frameTreeElement) {
     163            console.error("No frame with id:" + frameId + " to remove resources from.");
     164            return;
     165        }
     166        frameTreeElement.removeChildren();
    113167    },
    114168
    … …  
    165219            domStorage._domStorageTreeElement.select();
    166220        }
     221    },
     222
     223    showResource: function(resource)
     224    {
     225        var view = WebInspector.ResourceManager.resourceViewForResource(resource);
     226        view.headersVisible = false;
     227        this._innerShowView(view);
    167228    },
    168229
    … …  
    429490        this.listItemElement.addStyleClass(this._iconClass);
    430491
    431         var imageElement = document.createElement("img");
    432         imageElement.className = "icon";
    433         this.listItemElement.appendChild(imageElement);
     492        this.imageElement = document.createElement("img");
     493        this.imageElement.className = "icon";
     494        this.listItemElement.appendChild(this.imageElement);
    434495
    435496        var titleElement = document.createElement("span");
    … …  
    441502        selectionElement.className = "selection";
    442503        this.listItemElement.appendChild(selectionElement);
     504    },
     505
     506    onreveal: function()
     507    {
     508        if (this.listItemElement)
     509            this.listItemElement.scrollIntoViewIfNeeded(false);
    443510    }
    444511}
    … …  
    459526}
    460527WebInspector.StorageCategoryTreeElement.prototype.__proto__ = WebInspector.BaseStorageTreeElement.prototype;
     528
     529WebInspector.FrameTreeElement = function(storagePanel, frameId, frameResource)
     530{
     531    WebInspector.BaseStorageTreeElement.call(this, storagePanel, frameResource.displayName, "frame-storage-tree-item");
     532    this._frameId = frameId;
     533    this._resource = frameResource;
     534}
     535
     536WebInspector.FrameTreeElement.prototype = {
     537    onselect: function()
     538    {
     539        this._storagePanel.showResource(this._resource);
     540    }
     541}
     542WebInspector.FrameTreeElement.prototype.__proto__ = WebInspector.BaseStorageTreeElement.prototype;
     543
     544WebInspector.FrameResourceTreeElement = function(storagePanel, resource)
     545{
     546    WebInspector.BaseStorageTreeElement.call(this, storagePanel, resource.displayName, "resource-sidebar-tree-item resources-category-" + resource.category.name);
     547    this._resource = resource;
     548}
     549
     550WebInspector.FrameResourceTreeElement.prototype = {
     551    onselect: function()
     552    {
     553        this._storagePanel.showResource(this._resource);
     554    },
     555
     556    onattach: function()
     557    {
     558        WebInspector.BaseStorageTreeElement.prototype.onattach.call(this);
     559
     560        if (this._resource.category === WebInspector.resourceCategories.images) {
     561            var previewImage = document.createElement("img");
     562            previewImage.className = "image-resource-icon-preview";
     563            previewImage.src = this._resource.url;
     564
     565            var iconElement = document.createElement("div");
     566            iconElement.className = "icon";
     567            iconElement.appendChild(previewImage);
     568            this.listItemElement.replaceChild(iconElement, this.imageElement);
     569        }
     570    }
     571}
     572
     573WebInspector.FrameResourceTreeElement.prototype.__proto__ = WebInspector.BaseStorageTreeElement.prototype;
    461574
    462575WebInspector.DatabaseTreeElement = function(storagePanel, database)

  • trunk/WebCore/inspector/front-end/WebKit.qrc

    r70137 r70240  
    159159    <file>Images/focusButtonGlyph.png</file>
    160160    <file>Images/forward.png</file>
     161    <file>Images/frame.png</file>
    161162    <file>Images/gearButtonGlyph.png</file>
    162163    <file>Images/glossyHeader.png</file>

  • trunk/WebCore/inspector/front-end/inspector.css

    r70214 r70240  
    18821882}
    18831883
     1884.frame-storage-tree-item .icon {
     1885    content: url(Images/frame.png);
     1886}
     1887
    18841888.database-storage-tree-item .icon {
    18851889    content: url(Images/database.png);
    … …  
    19201924}
    19211925
    1922 .storage.panel .outline-disclosure > ol {
     1926.storage.panel .sidebar.outline-disclosure > ol {
    19231927    margin-left: -12px;
    19241928    padding-right: 0px !important;
    … …  
    33953399}
    33963400
    3397 .resource-sidebar-tree-item.resources-category-images .image-resource-icon-preview {
     3401.resources-category-images .image-resource-icon-preview {
    33983402    position: absolute;
    33993403    margin: auto;
    … …  
    34133417}
    34143418
    3415 .children.small .resource-sidebar-tree-item.resources-category-images .image-resource-icon-preview {
     3419.children.small .resources-category-images .image-resource-icon-preview {
    34163420    top: 2px;
    34173421    bottom: 1px;

  • trunk/WebCore/inspector/front-end/inspector.js

    r70045 r70240  
    508508    // TODO: Remove class="hidden" from inspector.html on button#changes-status-bar-item
    509509    this.drawer.visibleView = this.console;
    510     // FIXME: uncomment when ready.
    511     // this.resourceManager = new WebInspector.ResourceManager();
     510    if (Preferences.networkPanelEnabled)
     511        this.resourceManager = new WebInspector.ResourceManager();
    512512    this.domAgent = new WebInspector.DOMAgent();
    513513
Note: See TracChangeset for help on using the changeset viewer.