Changeset 62529 in webkit


Ignore:
Timestamp:
Jul 5, 2010 11:48:57 PM (14 years ago)
Author:
hamaji@chromium.org
Message:

2010-07-05 Yuta Kitamura <​yutak@chromium.org>

Reviewed by Pavel Feldman.

Add WebSocket resource type to Web Inspector.

When a new WebSocket connection is established, a line for that connection
will appear in Web Inspector's Resources tab. If the resource name is
clicked, the details of handshake request and response will be shown.

Web Inspector: WebSocket in Resources tab
​https://bugs.webkit.org/show_bug.cgi?id=40768

  • inspector/InspectorController.cpp: (WebCore::InspectorController::addResource): WebSocket resource does not have an associated loader, thus frame might be null. Need to check it. (WebCore::InspectorController::removeResource): Ditto. (WebCore::InspectorController::didCreateWebSocket): (WebCore::InspectorController::willSendWebSocketHandshakeRequest): (WebCore::InspectorController::didReceiveWebSocketHandshakeResponse): (WebCore::InspectorController::didCloseWebSocket):
  • inspector/InspectorController.h:
  • inspector/InspectorResource.cpp: Add null checks of m_loader and m_frame, because WebSocket does not have a loader and we need to allow null for these variables. (WebCore::createReadableStringFromBinary): (WebCore::InspectorResource::InspectorResource): (WebCore::InspectorResource::create): Factory function of regular (non-WebSocket) resources. (WebCore::InspectorResource::createWebSocket): Factory function of WebSocket resources. (WebCore::InspectorResource::updateWebSocketRequest): (WebCore::InspectorResource::updateWebSocketResponse): (WebCore::InspectorResource::updateScriptObject): (WebCore::InspectorResource::cachedResource): (WebCore::InspectorResource::type): (WebCore::InspectorResource::resourceData):
  • inspector/InspectorResource.h: (WebCore::InspectorResource::): (WebCore::InspectorResource::markWebSocket):
  • inspector/front-end/Resource.js: (WebInspector.Resource.Type.toString): (WebInspector.Resource.prototype.set type): (WebInspector.Resource.prototype._mimeTypeIsConsistentWithType):
  • inspector/front-end/ResourceView.js: (WebInspector.ResourceView.prototype._refreshRequestHeaders): (WebInspector.ResourceView.prototype._refreshResponseHeaders): (WebInspector.ResourceView.prototype._refreshHeaders):
  • inspector/front-end/inspector.css: (.resources-category-websockets, .resources-category-other): (.resources-category-websockets .resources-graph-bar): (.resources-category-websockets.resource-cached .resources-graph-bar):
  • inspector/front-end/inspector.js: (WebInspector.loaded): (WebInspector.updateResource):
  • websockets/WebSocketChannel.cpp: (WebCore::WebSocketChannel::WebSocketChannel): (WebCore::WebSocketChannel::disconnect): (WebCore::WebSocketChannel::didOpen): (WebCore::WebSocketChannel::didClose): (WebCore::WebSocketChannel::processBuffer): (WebCore::WebSocketChannel::identifier):
  • websockets/WebSocketChannel.h:
Location:
trunk/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r62528 r62529  
     12010-07-05  Yuta Kitamura  <yutak@chromium.org>
     2
     3        Reviewed by Pavel Feldman.
     4
     5        Add WebSocket resource type to Web Inspector.
     6
     7        When a new WebSocket connection is established, a line for that connection
     8        will appear in Web Inspector's Resources tab. If the resource name is
     9        clicked, the details of handshake request and response will be shown.
     10
     11        Web Inspector: WebSocket in Resources tab
     12        https://bugs.webkit.org/show_bug.cgi?id=40768
     13
     14        * inspector/InspectorController.cpp:
     15        (WebCore::InspectorController::addResource): WebSocket resource does not
     16        have an associated loader, thus frame might be null. Need to check it.
     17        (WebCore::InspectorController::removeResource): Ditto.
     18        (WebCore::InspectorController::didCreateWebSocket):
     19        (WebCore::InspectorController::willSendWebSocketHandshakeRequest):
     20        (WebCore::InspectorController::didReceiveWebSocketHandshakeResponse):
     21        (WebCore::InspectorController::didCloseWebSocket):
     22        * inspector/InspectorController.h:
     23        * inspector/InspectorResource.cpp: Add null checks of m_loader and m_frame,
     24        because WebSocket does not have a loader and we need to allow null for
     25        these variables.
     26        (WebCore::createReadableStringFromBinary):
     27        (WebCore::InspectorResource::InspectorResource):
     28        (WebCore::InspectorResource::create): Factory function of
     29        regular (non-WebSocket) resources.
     30        (WebCore::InspectorResource::createWebSocket): Factory function of
     31        WebSocket resources.
     32        (WebCore::InspectorResource::updateWebSocketRequest):
     33        (WebCore::InspectorResource::updateWebSocketResponse):
     34        (WebCore::InspectorResource::updateScriptObject):
     35        (WebCore::InspectorResource::cachedResource):
     36        (WebCore::InspectorResource::type):
     37        (WebCore::InspectorResource::resourceData):
     38        * inspector/InspectorResource.h:
     39        (WebCore::InspectorResource::):
     40        (WebCore::InspectorResource::markWebSocket):
     41        * inspector/front-end/Resource.js:
     42        (WebInspector.Resource.Type.toString):
     43        (WebInspector.Resource.prototype.set type):
     44        (WebInspector.Resource.prototype._mimeTypeIsConsistentWithType):
     45        * inspector/front-end/ResourceView.js:
     46        (WebInspector.ResourceView.prototype._refreshRequestHeaders):
     47        (WebInspector.ResourceView.prototype._refreshResponseHeaders):
     48        (WebInspector.ResourceView.prototype._refreshHeaders):
     49        * inspector/front-end/inspector.css:
     50        (.resources-category-websockets, .resources-category-other):
     51        (.resources-category-websockets .resources-graph-bar):
     52        (.resources-category-websockets.resource-cached .resources-graph-bar):
     53        * inspector/front-end/inspector.js:
     54        (WebInspector.loaded):
     55        (WebInspector.updateResource):
     56        * websockets/WebSocketChannel.cpp:
     57        (WebCore::WebSocketChannel::WebSocketChannel):
     58        (WebCore::WebSocketChannel::disconnect):
     59        (WebCore::WebSocketChannel::didOpen):
     60        (WebCore::WebSocketChannel::didClose):
     61        (WebCore::WebSocketChannel::processBuffer):
     62        (WebCore::WebSocketChannel::identifier):
     63        * websockets/WebSocketChannel.h:
     64
    1652010-07-05  Yury Semikhatsky  <yurys@chromium.org>
    266

  • trunk/WebCore/inspector/InspectorController.cpp

    r62503 r62529  
    806806
    807807    Frame* frame = resource->frame();
     808    if (!frame)
     809        return;
    808810    ResourcesMap* resourceMap = m_frameResources.get(frame);
    809811    if (resourceMap)
    … …  
    824826
    825827    Frame* frame = resource->frame();
     828    if (!frame)
     829        return;
    826830    ResourcesMap* resourceMap = m_frameResources.get(frame);
    827831    if (!resourceMap) {
    … …  
    14661470}
    14671471#endif
     1472
     1473#if ENABLE(WEB_SOCKETS)
     1474void InspectorController::didCreateWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL)
     1475{
     1476    if (!enabled())
     1477        return;
     1478    ASSERT(m_inspectedPage);
     1479
     1480    RefPtr<InspectorResource> resource = InspectorResource::createWebSocket(identifier, requestURL, documentURL);
     1481    addResource(resource.get());
     1482
     1483    if (m_frontend)
     1484        resource->updateScriptObject(m_frontend.get());
     1485}
     1486
     1487void InspectorController::willSendWebSocketHandshakeRequest(unsigned long identifier, const WebSocketHandshakeRequest& request)
     1488{
     1489    RefPtr<InspectorResource> resource = getTrackedResource(identifier);
     1490    if (!resource)
     1491        return;
     1492    resource->startTiming();
     1493    resource->updateWebSocketRequest(request);
     1494    if (m_frontend)
     1495        resource->updateScriptObject(m_frontend.get());
     1496}
     1497
     1498void InspectorController::didReceiveWebSocketHandshakeResponse(unsigned long identifier, const WebSocketHandshakeResponse& response)
     1499{
     1500    RefPtr<InspectorResource> resource = getTrackedResource(identifier);
     1501    if (!resource)
     1502        return;
     1503    // Calling resource->markResponseReceivedTime() here makes resources bar chart confusing, because
     1504    // we cannot apply the "latency + download" model of regular resources to WebSocket connections.
     1505    // FIXME: Design a new UI for bar charts of WebSocket resources, and record timing here.
     1506    resource->updateWebSocketResponse(response);
     1507    if (m_frontend)
     1508        resource->updateScriptObject(m_frontend.get());
     1509}
     1510
     1511void InspectorController::didCloseWebSocket(unsigned long identifier)
     1512{
     1513    RefPtr<InspectorResource> resource = getTrackedResource(identifier);
     1514    if (!resource)
     1515        return;
     1516
     1517    resource->endTiming();
     1518    if (m_frontend)
     1519        resource->updateScriptObject(m_frontend.get());
     1520}
     1521#endif // ENABLE(WEB_SOCKETS)
    14681522
    14691523#if ENABLE(JAVASCRIPT_DEBUGGER)

  • trunk/WebCore/inspector/InspectorController.h

    r62503 r62529  
    9191#endif
    9292
     93#if ENABLE(WEB_SOCKETS)
     94class WebSocketHandshakeRequest;
     95class WebSocketHandshakeResponse;
     96#endif
     97
    9398class InspectorController
    9499#if ENABLE(JAVASCRIPT_DEBUGGER)
    … …  
    216221    void removeDOMStorageItem(long callId, long storageId, const String& key);
    217222#endif
     223#if ENABLE(WEB_SOCKETS)
     224    void didCreateWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL);
     225    void willSendWebSocketHandshakeRequest(unsigned long identifier, const WebSocketHandshakeRequest&);
     226    void didReceiveWebSocketHandshakeResponse(unsigned long identifier, const WebSocketHandshakeResponse&);
     227    void didCloseWebSocket(unsigned long identifier);
     228#endif
    218229
    219230    const ResourcesMap& resources() const { return m_resources; }

  • trunk/WebCore/inspector/InspectorResource.cpp

    r61012 r62529  
    4242#include "ResourceRequest.h"
    4343#include "ResourceResponse.h"
     44#include "StringBuffer.h"
    4445#include "TextEncoding.h"
    4546#include "ScriptObject.h"
     47#include "WebSocketHandshakeRequest.h"
     48#include "WebSocketHandshakeResponse.h"
     49
     50#include <wtf/Assertions.h>
    4651
    4752namespace WebCore {
    4853
    49 InspectorResource::InspectorResource(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
     54// Create human-readable binary representation, like "01:23:45:67:89:AB:CD:EF".
     55static String createReadableStringFromBinary(const unsigned char* value, size_t length)
     56{
     57    ASSERT(length > 0);
     58    static const char hexDigits[17] = "0123456789ABCDEF";
     59    size_t bufferSize = length * 3 - 1;
     60    StringBuffer buffer(bufferSize);
     61    size_t index = 0;
     62    for (size_t i = 0; i < length; ++i) {
     63        if (i > 0)
     64            buffer[index++] = ':';
     65        buffer[index++] = hexDigits[value[i] >> 4];
     66        buffer[index++] = hexDigits[value[i] & 0xF];
     67    }
     68    ASSERT(index == bufferSize);
     69    return String::adopt(buffer);
     70}
     71
     72InspectorResource::InspectorResource(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL, const KURL& documentURL)
    5073    : m_identifier(identifier)
    5174    , m_loader(loader)
    52     , m_frame(loader->frame())
     75    , m_frame(loader ? loader->frame() : 0)
    5376    , m_requestURL(requestURL)
     77    , m_documentURL(documentURL)
    5478    , m_expectedContentLength(0)
    5579    , m_cached(false)
    … …  
    6488    , m_domContentEventTime(-1.0)
    6589    , m_isMainResource(false)
     90#if ENABLE(WEB_SOCKETS)
     91    , m_isWebSocket(false)
     92#endif
    6693{
    6794}
    … …  
    86113}
    87114
     115PassRefPtr<InspectorResource> InspectorResource::create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
     116{
     117    ASSERT(loader);
     118    return adoptRef(new InspectorResource(identifier, loader, requestURL, loader->frame()->document()->url()));
     119}
     120
    88121PassRefPtr<InspectorResource> InspectorResource::createCached(unsigned long identifier, DocumentLoader* loader, const CachedResource* cachedResource)
    89122{
    … …  
    104137    return resource;
    105138}
     139
     140#if ENABLE(WEB_SOCKETS)
     141PassRefPtr<InspectorResource> InspectorResource::createWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL)
     142{
     143    RefPtr<InspectorResource> resource(new InspectorResource(identifier, 0, requestURL, documentURL));
     144    resource->markWebSocket();
     145    return resource.release();
     146}
     147#endif
    106148
    107149void InspectorResource::updateRequest(const ResourceRequest& request)
    … …  
    133175}
    134176
     177#if ENABLE(WEB_SOCKETS)
     178void InspectorResource::updateWebSocketRequest(const WebSocketHandshakeRequest& request)
     179{
     180    m_requestHeaderFields = request.headerFields();
     181    m_requestMethod = "GET"; // Currently we always use "GET" to request handshake.
     182    m_webSocketRequestKey3.set(new WebSocketHandshakeRequest::Key3(request.key3()));
     183    m_changes.set(RequestChange);
     184    m_changes.set(TypeChange);
     185}
     186
     187void InspectorResource::updateWebSocketResponse(const WebSocketHandshakeResponse& response)
     188{
     189    m_responseStatusCode = response.statusCode();
     190    m_responseStatusText = response.statusText();
     191    m_responseHeaderFields = response.headerFields();
     192    m_webSocketChallengeResponse.set(new WebSocketHandshakeResponse::ChallengeResponse(response.challengeResponse()));
     193    m_changes.set(ResponseChange);
     194    m_changes.set(TypeChange);
     195}
     196#endif // ENABLE(WEB_SOCKETS)
     197
    135198static void populateHeadersObject(ScriptObject* object, const HTTPHeaderMap& headers)
    136199{
    … …  
    150213    if (m_changes.hasChange(RequestChange)) {
    151214        jsonObject.set("url", m_requestURL.string());
    152         jsonObject.set("documentURL", m_frame->document()->url().string());
     215        jsonObject.set("documentURL", m_documentURL.string());
    153216        jsonObject.set("host", m_requestURL.host());
    154217        jsonObject.set("path", m_requestURL.path());
    … …  
    162225        jsonObject.set("didRequestChange", true);
    163226        jsonObject.set("cached", m_cached);
     227#if ENABLE(WEB_SOCKETS)
     228        if (m_webSocketRequestKey3)
     229            jsonObject.set("webSocketRequestKey3", createReadableStringFromBinary(m_webSocketRequestKey3->value, sizeof(m_webSocketRequestKey3->value)));
     230#endif
    164231    }
    165232
    … …  
    173240        populateHeadersObject(&responseHeaders, m_responseHeaderFields);
    174241        jsonObject.set("responseHeaders", responseHeaders);
     242#if ENABLE(WEB_SOCKETS)
     243        if (m_webSocketChallengeResponse)
     244            jsonObject.set("webSocketChallengeResponse", createReadableStringFromBinary(m_webSocketChallengeResponse->value, sizeof(m_webSocketChallengeResponse->value)));
     245#endif
    175246        jsonObject.set("didResponseChange", true);
    176247    }
    … …  
    231302    // but Inspector will already try to fetch data that is only available via CachedResource (and it won't update once the resource is added,
    232303    // because m_changes will not have the appropriate bits set).
     304    if (!m_frame)
     305        return 0;
    233306    const String& url = m_requestURL.string();
    234307    CachedResource* cachedResource = m_frame->document()->docLoader()->cachedResource(url);
    … …  
    267340        return m_overrideContentType;
    268341
     342#if ENABLE(WEB_SOCKETS)
     343    if (m_isWebSocket)
     344        return WebSocket;
     345#endif
     346
     347    ASSERT(m_loader);
    269348    if (m_requestURL == m_loader->requestURL()) {
    270349        InspectorResource::Type resourceType = cachedResourceType();
    … …  
    306385PassRefPtr<SharedBuffer> InspectorResource::resourceData(String* textEncodingName) const
    307386{
    308     if (m_requestURL == m_loader->requestURL()) {
     387    if (m_loader && m_requestURL == m_loader->requestURL()) {
    309388        *textEncodingName = m_frame->document()->inputEncoding();
    310389        return m_loader->mainResourceData();

  • trunk/WebCore/inspector/InspectorResource.h

    r60206 r62529  
    3737#include "ScriptState.h"
    3838#include "ScriptString.h"
     39#include "WebSocketHandshakeRequest.h"
     40#include "WebSocketHandshakeResponse.h"
    3941
    4042#include <wtf/CurrentTime.h>
    … …  
    5153    class Frame;
    5254    class ResourceResponse;
    53 
    5455    class ResourceRequest;
     56
     57#if ENABLE(WEB_SOCKETS)
     58    class WebSocketHandshakeRequest;
     59    class WebSocketHandshakeResponse;
     60#endif
    5561
    5662    class InspectorResource : public RefCounted<InspectorResource> {
    … …  
    6672            XHR,
    6773            Media,
     74            WebSocket,
    6875            Other
    6976        };
    7077
    71         static PassRefPtr<InspectorResource> create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
    72         {
    73             return adoptRef(new InspectorResource(identifier, loader, requestURL));
    74         }
     78        static PassRefPtr<InspectorResource> create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL);
    7579
    7680        static PassRefPtr<InspectorResource> createCached(unsigned long identifier, DocumentLoader*, const CachedResource*);
     81
     82#if ENABLE(WEB_SOCKETS)
     83        // WebSocket resource doesn't have its loader. For WebSocket resources, m_loader and m_frame will become null.
     84        static PassRefPtr<InspectorResource> createWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL);
     85#endif
    7786
    7887        ~InspectorResource();
    … …  
    8493        void updateRequest(const ResourceRequest&);
    8594        void updateResponse(const ResourceResponse&);
     95
     96#if ENABLE(WEB_SOCKETS)
     97        void updateWebSocketRequest(const WebSocketHandshakeRequest&);
     98        void updateWebSocketResponse(const WebSocketHandshakeResponse&);
     99#endif
    86100
    87101        void setOverrideContent(const ScriptString& data, Type);
    … …  
    147161        };
    148162
    149         InspectorResource(unsigned long identifier, DocumentLoader*, const KURL& requestURL);
     163        InspectorResource(unsigned long identifier, DocumentLoader*, const KURL& requestURL, const KURL& documentURL);
    150164        Type type() const;
    151165
    152166        Type cachedResourceType() const;
    153167        CachedResource* cachedResource() const;
     168
     169#if ENABLE(WEB_SOCKETS)
     170        void markWebSocket() { m_isWebSocket = true; }
     171#endif
    154172
    155173        unsigned long m_identifier;
    … …  
    157175        RefPtr<Frame> m_frame;
    158176        KURL m_requestURL;
     177        KURL m_documentURL;
    159178        HTTPHeaderMap m_requestHeaderFields;
    160179        HTTPHeaderMap m_responseHeaderFields;
    … …  
    180199        String m_requestFormData;
    181200        Vector<RefPtr<InspectorResource> > m_redirects;
     201
     202#if ENABLE(WEB_SOCKETS)
     203        bool m_isWebSocket;
     204
     205        // The following fields are not used for resources other than WebSocket.
     206        // We allocate them dynamically to reduce memory consumption for regular resources.
     207        OwnPtr<WebSocketHandshakeRequest::Key3> m_webSocketRequestKey3;
     208        OwnPtr<WebSocketHandshakeResponse::ChallengeResponse> m_webSocketChallengeResponse;
     209#endif
    182210    };
    183211

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

    r60562 r62529  
    4646    XHR:        5,
    4747    Media:      6,
    48     Other:      7,
     48    WebSocket:  7,
     49    Other:      8,
    4950
    5051    isTextType: function(type)
    … …  
    6869            case this.XHR:
    6970                return WebInspector.UIString("XHR");
     71            case this.WebSocket:
     72                return WebInspector.UIString("WebSocket");
    7073            case this.Other:
    7174            default:
    … …  
    353356                this.category = WebInspector.resourceCategories.xhr;
    354357                break;
     358            case WebInspector.Resource.Type.WebSocket:
     359                this.category = WebInspector.resourceCategories.websocket;
     360                break;
    355361            case WebInspector.Resource.Type.Other:
    356362            default:
    … …  
    565571        if (typeof this.type === "undefined"
    566572         || this.type === WebInspector.Resource.Type.Other
    567          || this.type === WebInspector.Resource.Type.XHR)
     573         || this.type === WebInspector.Resource.Type.XHR
     574         || this.type === WebInspector.Resource.Type.WebSocket)
    568575            return true;
    569576

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

    r61014 r62529  
    279279    _refreshRequestHeaders: function()
    280280    {
    281         this._refreshHeaders(WebInspector.UIString("Request Headers"), this.resource.sortedRequestHeaders, this.requestHeadersTreeElement);
     281        var additionalRow = null;
     282        if (typeof this.resource.webSocketRequestKey3 !== "undefined")
     283            additionalRow = {header: "(Key3)", value: this.resource.webSocketRequestKey3};
     284        this._refreshHeaders(WebInspector.UIString("Request Headers"), this.resource.sortedRequestHeaders, additionalRow, this.requestHeadersTreeElement);
    282285        this._refreshFormData();
    283286    },
    … …  
    285288    _refreshResponseHeaders: function()
    286289    {
    287         this._refreshHeaders(WebInspector.UIString("Response Headers"), this.resource.sortedResponseHeaders, this.responseHeadersTreeElement);
     290        var additionalRow = null;
     291        if (typeof this.resource.webSocketChallengeResponse !== "undefined")
     292            additionalRow = {header: "(Challenge Response)", value: this.resource.webSocketChallengeResponse};
     293        this._refreshHeaders(WebInspector.UIString("Response Headers"), this.resource.sortedResponseHeaders, additionalRow, this.responseHeadersTreeElement);
    288294    },
    289295
    … …  
    316322    },
    317323   
    318     _refreshHeaders: function(title, headers, headersTreeElement)
     324    _refreshHeaders: function(title, headers, additionalRow, headersTreeElement)
    319325    {
    320326        headersTreeElement.removeChildren();
    … …  
    333339            headersTreeElement.appendChild(headerTreeElement);
    334340        }
     341
     342        if (additionalRow) {
     343            var title = "<div class=\"header-name\">" + additionalRow.header.escapeHTML() + ":</div>";
     344            title += "<div class=\"header-value source-code\">" + additionalRow.value.escapeHTML() + "</div>"
     345
     346            var headerTreeElement = new TreeElement(title, null, false);
     347            headerTreeElement.selectable = false;
     348            headersTreeElement.appendChild(headerTreeElement);
     349        }
    335350    }
    336351}

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

    r62502 r62529  
    28042804
    28052805.resources-category-documents, .resources-category-stylesheets, .resources-category-images,
    2806 .resources-category-scripts, .resources-category-xhr, .resources-category-fonts, .resources-category-other {
     2806.resources-category-scripts, .resources-category-xhr, .resources-category-fonts,
     2807.resources-category-websockets, .resources-category-other {
    28072808    display: none;
    28082809}
    … …  
    28142815.filter-all .resources-category-xhr, .filter-xhr .resources-category-xhr,
    28152816.filter-all .resources-category-fonts, .filter-fonts .resources-category-fonts,
     2817.filter-all .resources-category-websockets, .filter-websockets .resources-category-websockets,
    28162818.filter-all .resources-category-other, .filter-other .resources-category-other,
    28172819.resource-sidebar-tree-item.selected {
    … …  
    28872889.resources-category-xhr.resource-cached .resources-graph-bar {
    28882890    -webkit-border-image: url(Images/timelineHollowPillYellow.png) 6 7 6 7;
     2891}
     2892
     2893/* FIXME: Create bar images for WebSocket. */
     2894.resources-category-websockets .resources-graph-bar {
     2895    -webkit-border-image: url(Images/timelinePillGray.png) 6 7 6 7;
     2896}
     2897
     2898.resources-category-websockets.resource-cached .resources-graph-bar {
     2899   -webkit-border-image: url(Images/timelineHollowPillGray.png) 6 7 6 7;
    28892900}
    28902901

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

    r62503 r62529  
    465465        xhr: new WebInspector.ResourceCategory("xhr", WebInspector.UIString("XHR"), "rgb(231,231,10)"),
    466466        fonts: new WebInspector.ResourceCategory("fonts", WebInspector.UIString("Fonts"), "rgb(255,82,62)"),
     467        websocket: new WebInspector.ResourceCategory("websockets", WebInspector.UIString("WebSocket"), "rgb(186,186,186)"), // FIXME: Decide the color.
    467468        other: new WebInspector.ResourceCategory("other", WebInspector.UIString("Other"), "rgb(186,186,186)")
    468469    };
    … …  
    11621163        resource.cached = payload.cached;
    11631164        resource.documentURL = payload.documentURL;
     1165        if (typeof payload.webSocketRequestKey3 !== "undefined")
     1166            resource.webSocketRequestKey3 = payload.webSocketRequestKey3;
    11641167
    11651168        if (resource.mainResource)
    … …  
    11821185        resource.suggestedFilename = payload.suggestedFilename;
    11831186        resource.responseHeaders = payload.responseHeaders;
     1187        if (typeof payload.webSocketChallengeResponse !== "undefined")
     1188            resource.webSocketChallengeResponse = payload.webSocketChallengeResponse;
    11841189    }
    11851190

  • trunk/WebCore/websockets/WebSocketChannel.cpp

    r61375 r62529  
    3737#include "CookieJar.h"
    3838#include "Document.h"
     39#include "InspectorController.h"
    3940#include "Logging.h"
     41#include "Page.h"
    4042#include "PlatformString.h"
     43#include "ProgressTracker.h"
    4144#include "ScriptExecutionContext.h"
    4245#include "SocketStreamError.h"
    … …  
    6366    , m_closed(false)
    6467    , m_unhandledBufferedAmount(0)
    65 {
     68#if ENABLE(INSPECTOR)
     69    , m_identifier(0)
     70#endif
     71{
     72#if ENABLE(INSPECTOR)
     73    if (InspectorController* controller = m_context->inspectorController())
     74        controller->didCreateWebSocket(identifier(), url, m_context->url());
     75#endif
    6676}
    6777
    … …  
    112122{
    113123    LOG(Network, "WebSocketChannel %p disconnect", this);
     124#if ENABLE(INSPECTOR)
     125    if (m_context)
     126        if (InspectorController* controller = m_context->inspectorController())
     127            controller->didCloseWebSocket(identifier());
     128#endif
    114129    m_handshake.clearScriptExecutionContext();
    115130    m_client = 0;
    … …  
    137152    if (!m_context)
    138153        return;
     154#if ENABLE(INSPECTOR)
     155    if (InspectorController* controller = m_context->inspectorController())
     156        controller->willSendWebSocketHandshakeRequest(identifier(), m_handshake.clientHandshakeRequest());
     157#endif
    139158    const CString& handshakeMessage = m_handshake.clientHandshakeMessage();
    140159    if (!handle->send(handshakeMessage.data(), handshakeMessage.length())) {
    … …  
    147166{
    148167    LOG(Network, "WebSocketChannel %p didClose", this);
     168#if ENABLE(INSPECTOR)
     169    if (m_context)
     170        if (InspectorController* controller = m_context->inspectorController())
     171            controller->didCloseWebSocket(identifier());
     172#endif
    149173    ASSERT_UNUSED(handle, handle == m_handle || !m_handle);
    150174    m_closed = true;
    … …  
    238262            return false;
    239263        if (m_handshake.mode() == WebSocketHandshake::Connected) {
     264#if ENABLE(INSPECTOR)
     265            if (InspectorController* controller = m_context->inspectorController())
     266                controller->didReceiveWebSocketHandshakeResponse(identifier(), m_handshake.serverHandshakeResponse());
     267#endif
    240268            if (!m_handshake.serverSetCookie().isEmpty()) {
    241269                if (m_context->isDocument()) {
    … …  
    329357}
    330358
     359#if ENABLE(INSPECTOR)
     360unsigned long WebSocketChannel::identifier()
     361{
     362    if (m_identifier)
     363        return m_identifier;
     364
     365    if (InspectorController* controller = m_context->inspectorController())
     366        if (Page* page = controller->inspectedPage())
     367            m_identifier = page->progress()->createUniqueIdentifier();
     368
     369    ASSERT(m_identifier);
     370    return m_identifier;
     371}
     372#endif // ENABLE(INSPECTOR)
     373
    331374}  // namespace WebCore
    332375

  • trunk/WebCore/websockets/WebSocketChannel.h

    r61375 r62529  
    8585        void resumeTimerFired(Timer<WebSocketChannel>* timer);
    8686
     87#if ENABLE(INSPECTOR)
     88        unsigned long identifier();
     89#endif
     90
    8791        ScriptExecutionContext* m_context;
    8892        WebSocketChannelClient* m_client;
    … …  
    96100        bool m_closed;
    97101        unsigned long m_unhandledBufferedAmount;
     102
     103#if ENABLE(INSPECTOR)
     104        unsigned long m_identifier;
     105#endif
    98106    };
    99107
Note: See TracChangeset for help on using the changeset viewer.