Changeset 64142 in webkit


Ignore:
Timestamp:
Jul 27, 2010 11:14:31 AM (14 years ago)
Author:
victorw@chromium.org
Message:

2010-07-27 Victor Wang <victorw@chromium.org>

Unreviewed, rolling out r64104.
http://trac.webkit.org/changeset/64104
https://bugs.webkit.org/show_bug.cgi?id=40768

The patch causes chromium webkit socket laytest crashes on
windows randomly

  • inspector/InspectorController.cpp: (WebCore::InspectorController::addResource): (WebCore::InspectorController::removeResource):
  • inspector/InspectorController.h:
  • inspector/InspectorResource.cpp: (WebCore::InspectorResource::InspectorResource): (WebCore::InspectorResource::updateScriptObject): (WebCore::InspectorResource::cachedResource): (WebCore::InspectorResource::type): (WebCore::InspectorResource::resourceData):
  • inspector/InspectorResource.h: (WebCore::InspectorResource::): (WebCore::InspectorResource::create):
  • 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-scripts, .resources-category-xhr, .resources-category-fonts, .resources-category-other):
  • 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):
  • websockets/WebSocketChannel.h:
Location:
trunk/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/ChangeLog

    r64141 r64142  
     12010-07-27  Victor Wang  <victorw@chromium.org>
     2
     3        Unreviewed, rolling out r64104.
     4        http://trac.webkit.org/changeset/64104
     5        https://bugs.webkit.org/show_bug.cgi?id=40768
     6
     7        The patch causes chromium webkit socket laytest crashes on
     8        windows randomly
     9
     10        * inspector/InspectorController.cpp:
     11        (WebCore::InspectorController::addResource):
     12        (WebCore::InspectorController::removeResource):
     13        * inspector/InspectorController.h:
     14        * inspector/InspectorResource.cpp:
     15        (WebCore::InspectorResource::InspectorResource):
     16        (WebCore::InspectorResource::updateScriptObject):
     17        (WebCore::InspectorResource::cachedResource):
     18        (WebCore::InspectorResource::type):
     19        (WebCore::InspectorResource::resourceData):
     20        * inspector/InspectorResource.h:
     21        (WebCore::InspectorResource::):
     22        (WebCore::InspectorResource::create):
     23        * inspector/front-end/Resource.js:
     24        (WebInspector.Resource.Type.toString):
     25        (WebInspector.Resource.prototype.set type):
     26        (WebInspector.Resource.prototype._mimeTypeIsConsistentWithType):
     27        * inspector/front-end/ResourceView.js:
     28        (WebInspector.ResourceView.prototype._refreshRequestHeaders):
     29        (WebInspector.ResourceView.prototype._refreshResponseHeaders):
     30        (WebInspector.ResourceView.prototype._refreshHeaders):
     31        * inspector/front-end/inspector.css:
     32        (.resources-category-scripts, .resources-category-xhr, .resources-category-fonts, .resources-category-other):
     33        * inspector/front-end/inspector.js:
     34        (WebInspector.loaded):
     35        (WebInspector.updateResource):
     36        * websockets/WebSocketChannel.cpp:
     37        (WebCore::WebSocketChannel::WebSocketChannel):
     38        (WebCore::WebSocketChannel::disconnect):
     39        (WebCore::WebSocketChannel::didOpen):
     40        (WebCore::WebSocketChannel::didClose):
     41        (WebCore::WebSocketChannel::processBuffer):
     42        * websockets/WebSocketChannel.h:
     43
    1442010-07-27  Andrei Popescu  <andreip@google.com>
    245
  • trunk/WebCore/inspector/InspectorController.cpp

    r64104 r64142  
    827827
    828828    Frame* frame = resource->frame();
    829     if (!frame)
    830         return;
    831829    ResourcesMap* resourceMap = m_frameResources.get(frame);
    832830    if (resourceMap)
     
    847845
    848846    Frame* frame = resource->frame();
    849     if (!frame)
    850         return;
    851847    ResourcesMap* resourceMap = m_frameResources.get(frame);
    852848    if (!resourceMap) {
     
    14911487}
    14921488#endif
    1493 
    1494 #if ENABLE(WEB_SOCKETS)
    1495 void InspectorController::didCreateWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL)
    1496 {
    1497     if (!enabled())
    1498         return;
    1499     ASSERT(m_inspectedPage);
    1500 
    1501     RefPtr<InspectorResource> resource = InspectorResource::createWebSocket(identifier, requestURL, documentURL);
    1502     addResource(resource.get());
    1503 
    1504     if (m_frontend)
    1505         resource->updateScriptObject(m_frontend.get());
    1506 }
    1507 
    1508 void InspectorController::willSendWebSocketHandshakeRequest(unsigned long identifier, const WebSocketHandshakeRequest& request)
    1509 {
    1510     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
    1511     if (!resource)
    1512         return;
    1513     resource->startTiming();
    1514     resource->updateWebSocketRequest(request);
    1515     if (m_frontend)
    1516         resource->updateScriptObject(m_frontend.get());
    1517 }
    1518 
    1519 void InspectorController::didReceiveWebSocketHandshakeResponse(unsigned long identifier, const WebSocketHandshakeResponse& response)
    1520 {
    1521     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
    1522     if (!resource)
    1523         return;
    1524     // Calling resource->markResponseReceivedTime() here makes resources bar chart confusing, because
    1525     // we cannot apply the "latency + download" model of regular resources to WebSocket connections.
    1526     // FIXME: Design a new UI for bar charts of WebSocket resources, and record timing here.
    1527     resource->updateWebSocketResponse(response);
    1528     if (m_frontend)
    1529         resource->updateScriptObject(m_frontend.get());
    1530 }
    1531 
    1532 void InspectorController::didCloseWebSocket(unsigned long identifier)
    1533 {
    1534     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
    1535     if (!resource)
    1536         return;
    1537 
    1538     resource->endTiming();
    1539     if (m_frontend)
    1540         resource->updateScriptObject(m_frontend.get());
    1541 }
    1542 #endif // ENABLE(WEB_SOCKETS)
    15431489
    15441490#if ENABLE(JAVASCRIPT_DEBUGGER)
  • trunk/WebCore/inspector/InspectorController.h

    r64104 r64142  
    9393#endif
    9494
    95 #if ENABLE(WEB_SOCKETS)
    96 class WebSocketHandshakeRequest;
    97 class WebSocketHandshakeResponse;
    98 #endif
    99 
    10095class InspectorController
    10196#if ENABLE(JAVASCRIPT_DEBUGGER)
     
    229224    void removeDOMStorageItem(long callId, long storageId, const String& key);
    230225#endif
    231 #if ENABLE(WEB_SOCKETS)
    232     void didCreateWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL);
    233     void willSendWebSocketHandshakeRequest(unsigned long identifier, const WebSocketHandshakeRequest&);
    234     void didReceiveWebSocketHandshakeResponse(unsigned long identifier, const WebSocketHandshakeResponse&);
    235     void didCloseWebSocket(unsigned long identifier);
    236 #endif
    237226
    238227    const ResourcesMap& resources() const { return m_resources; }
  • trunk/WebCore/inspector/InspectorResource.cpp

    r64104 r64142  
    4343#include "ResourceRequest.h"
    4444#include "ResourceResponse.h"
    45 #include "StringBuffer.h"
    4645#include "TextEncoding.h"
    4746#include "ScriptObject.h"
    48 #include "WebSocketHandshakeRequest.h"
    49 #include "WebSocketHandshakeResponse.h"
    50 
    51 #include <wtf/Assertions.h>
    5247
    5348namespace WebCore {
    54 
    55 // Create human-readable binary representation, like "01:23:45:67:89:AB:CD:EF".
    56 static String createReadableStringFromBinary(const unsigned char* value, size_t length)
    57 {
    58     ASSERT(length > 0);
    59     static const char hexDigits[17] = "0123456789ABCDEF";
    60     size_t bufferSize = length * 3 - 1;
    61     StringBuffer buffer(bufferSize);
    62     size_t index = 0;
    63     for (size_t i = 0; i < length; ++i) {
    64         if (i > 0)
    65             buffer[index++] = ':';
    66         buffer[index++] = hexDigits[value[i] >> 4];
    67         buffer[index++] = hexDigits[value[i] & 0xF];
    68     }
    69     ASSERT(index == bufferSize);
    70     return String::adopt(buffer);
    71 }
    7249
    7350InspectorResource::InspectorResource(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
    7451    : m_identifier(identifier)
    7552    , m_loader(loader)
    76     , m_frame(loader ? loader->frame() : 0)
     53    , m_frame(loader->frame())
    7754    , m_requestURL(requestURL)
    7855    , m_expectedContentLength(0)
     
    9067    , m_connectionReused(false)
    9168    , m_isMainResource(false)
    92 #if ENABLE(WEB_SOCKETS)
    93     , m_isWebSocket(false)
    94 #endif
    9569{
    9670}
     
    11589}
    11690
    117 PassRefPtr<InspectorResource> InspectorResource::create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
    118 {
    119     ASSERT(loader);
    120     return adoptRef(new InspectorResource(identifier, loader, requestURL));
    121 }
    122 
    12391PassRefPtr<InspectorResource> InspectorResource::createCached(unsigned long identifier, DocumentLoader* loader, const CachedResource* cachedResource)
    12492{
     
    139107    return resource;
    140108}
    141 
    142 #if ENABLE(WEB_SOCKETS)
    143 PassRefPtr<InspectorResource> InspectorResource::createWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL)
    144 {
    145     RefPtr<InspectorResource> resource = adoptRef(new InspectorResource(identifier, 0, requestURL));
    146     resource->markWebSocket();
    147     resource->m_documentURL = documentURL;
    148     return resource.release();
    149 }
    150 #endif
    151109
    152110void InspectorResource::updateRequest(const ResourceRequest& request)
     
    189147}
    190148
    191 #if ENABLE(WEB_SOCKETS)
    192 void InspectorResource::updateWebSocketRequest(const WebSocketHandshakeRequest& request)
    193 {
    194     m_requestHeaderFields = request.headerFields();
    195     m_requestMethod = "GET"; // Currently we always use "GET" to request handshake.
    196     m_webSocketRequestKey3.set(new WebSocketHandshakeRequest::Key3(request.key3()));
    197     m_changes.set(RequestChange);
    198     m_changes.set(TypeChange);
    199 }
    200 
    201 void InspectorResource::updateWebSocketResponse(const WebSocketHandshakeResponse& response)
    202 {
    203     m_responseStatusCode = response.statusCode();
    204     m_responseStatusText = response.statusText();
    205     m_responseHeaderFields = response.headerFields();
    206     m_webSocketChallengeResponse.set(new WebSocketHandshakeResponse::ChallengeResponse(response.challengeResponse()));
    207     m_changes.set(ResponseChange);
    208     m_changes.set(TypeChange);
    209 }
    210 #endif // ENABLE(WEB_SOCKETS)
    211 
    212149static void populateHeadersObject(ScriptObject* object, const HTTPHeaderMap& headers)
    213150{
     
    225162    ScriptObject jsonObject = frontend->newScriptObject();
    226163    if (m_changes.hasChange(RequestChange)) {
    227         if (m_frame)
    228             m_documentURL = m_frame->document()->url();
    229 
    230164        jsonObject.set("url", m_requestURL.string());
    231         jsonObject.set("documentURL", m_documentURL.string());
     165        jsonObject.set("documentURL", m_frame->document()->url().string());
    232166        jsonObject.set("host", m_requestURL.host());
    233167        jsonObject.set("path", m_requestURL.path());
     
    240174        jsonObject.set("requestFormData", m_requestFormData);
    241175        jsonObject.set("didRequestChange", true);
    242 #if ENABLE(WEB_SOCKETS)
    243         if (m_webSocketRequestKey3)
    244             jsonObject.set("webSocketRequestKey3", createReadableStringFromBinary(m_webSocketRequestKey3->value, sizeof(m_webSocketRequestKey3->value)));
    245 #endif
    246176    }
    247177
     
    260190        if (m_loadTiming && !m_cached)
    261191            jsonObject.set("timing", buildObjectForTiming(frontend, m_loadTiming.get()));
    262 #if ENABLE(WEB_SOCKETS)
    263         if (m_webSocketChallengeResponse)
    264             jsonObject.set("webSocketChallengeResponse", createReadableStringFromBinary(m_webSocketChallengeResponse->value, sizeof(m_webSocketChallengeResponse->value)));
    265 #endif
    266192        jsonObject.set("didResponseChange", true);
    267193    }
     
    322248    // but Inspector will already try to fetch data that is only available via CachedResource (and it won't update once the resource is added,
    323249    // because m_changes will not have the appropriate bits set).
    324     if (!m_frame)
    325         return 0;
    326250    const String& url = m_requestURL.string();
    327251    CachedResource* cachedResource = m_frame->document()->docLoader()->cachedResource(url);
     
    360284        return m_overrideContentType;
    361285
    362 #if ENABLE(WEB_SOCKETS)
    363     if (m_isWebSocket)
    364         return WebSocket;
    365 #endif
    366 
    367     ASSERT(m_loader);
    368286    if (m_requestURL == m_loader->requestURL()) {
    369287        InspectorResource::Type resourceType = cachedResourceType();
     
    405323PassRefPtr<SharedBuffer> InspectorResource::resourceData(String* textEncodingName) const
    406324{
    407     if (m_loader && m_requestURL == m_loader->requestURL()) {
     325    if (m_requestURL == m_loader->requestURL()) {
    408326        *textEncodingName = m_frame->document()->inputEncoding();
    409327        return m_loader->mainResourceData();
  • trunk/WebCore/inspector/InspectorResource.h

    r64104 r64142  
    3737#include "ScriptState.h"
    3838#include "ScriptString.h"
    39 #include "WebSocketHandshakeRequest.h"
    40 #include "WebSocketHandshakeResponse.h"
    4139
    4240#include <wtf/CurrentTime.h>
     
    5654    class ResourceResponse;
    5755
    58 #if ENABLE(WEB_SOCKETS)
    59     class WebSocketHandshakeRequest;
    60     class WebSocketHandshakeResponse;
    61 #endif
    62 
    6356    class InspectorResource : public RefCounted<InspectorResource> {
    6457    public:
     
    7366            XHR,
    7467            Media,
    75             WebSocket,
    7668            Other
    7769        };
    7870
    79         static PassRefPtr<InspectorResource> create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL);
     71        static PassRefPtr<InspectorResource> create(unsigned long identifier, DocumentLoader* loader, const KURL& requestURL)
     72        {
     73            return adoptRef(new InspectorResource(identifier, loader, requestURL));
     74        }
    8075
    8176        static PassRefPtr<InspectorResource> createCached(unsigned long identifier, DocumentLoader*, const CachedResource*);
    82 
    83 #if ENABLE(WEB_SOCKETS)
    84         // WebSocket resource doesn't have its loader. For WebSocket resources, m_loader and m_frame will become null.
    85         static PassRefPtr<InspectorResource> createWebSocket(unsigned long identifier, const KURL& requestURL, const KURL& documentURL);
    86 #endif
    8777
    8878        ~InspectorResource();
     
    9484        void updateRequest(const ResourceRequest&);
    9585        void updateResponse(const ResourceResponse&);
    96 
    97 #if ENABLE(WEB_SOCKETS)
    98         void updateWebSocketRequest(const WebSocketHandshakeRequest&);
    99         void updateWebSocketResponse(const WebSocketHandshakeResponse&);
    100 #endif
    10186
    10287        void setOverrideContent(const ScriptString& data, Type);
     
    169154        ScriptObject buildObjectForTiming(InspectorFrontend*, ResourceLoadTiming*);
    170155
    171 #if ENABLE(WEB_SOCKETS)
    172         void markWebSocket() { m_isWebSocket = true; }
    173 #endif
    174 
    175156        unsigned long m_identifier;
    176157        RefPtr<DocumentLoader> m_loader;
    177158        RefPtr<Frame> m_frame;
    178159        KURL m_requestURL;
    179         KURL m_documentURL;
    180160        HTTPHeaderMap m_requestHeaderFields;
    181161        HTTPHeaderMap m_responseHeaderFields;
     
    204184        String m_requestFormData;
    205185        Vector<RefPtr<InspectorResource> > m_redirects;
    206 
    207 #if ENABLE(WEB_SOCKETS)
    208         bool m_isWebSocket;
    209 
    210         // The following fields are not used for resources other than WebSocket.
    211         // We allocate them dynamically to reduce memory consumption for regular resources.
    212         OwnPtr<WebSocketHandshakeRequest::Key3> m_webSocketRequestKey3;
    213         OwnPtr<WebSocketHandshakeResponse::ChallengeResponse> m_webSocketChallengeResponse;
    214 #endif
    215186    };
    216187
  • trunk/WebCore/inspector/front-end/Resource.js

    r64104 r64142  
    4646    XHR:        5,
    4747    Media:      6,
    48     WebSocket:  7,
    49     Other:      8,
     48    Other:      7,
    5049
    5150    isTextType: function(type)
     
    6968            case this.XHR:
    7069                return WebInspector.UIString("XHR");
    71             case this.WebSocket:
    72                 return WebInspector.UIString("WebSocket");
    7370            case this.Other:
    7471            default:
     
    367364                this.category = WebInspector.resourceCategories.xhr;
    368365                break;
    369             case WebInspector.Resource.Type.WebSocket:
    370                 this.category = WebInspector.resourceCategories.websocket;
    371                 break;
    372366            case WebInspector.Resource.Type.Other:
    373367            default:
     
    582576        if (typeof this.type === "undefined"
    583577         || this.type === WebInspector.Resource.Type.Other
    584          || this.type === WebInspector.Resource.Type.XHR
    585          || this.type === WebInspector.Resource.Type.WebSocket)
     578         || this.type === WebInspector.Resource.Type.XHR)
    586579            return true;
    587580
  • trunk/WebCore/inspector/front-end/ResourceView.js

    r64104 r64142  
    279279    _refreshRequestHeaders: function()
    280280    {
    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);
     281        this._refreshHeaders(WebInspector.UIString("Request Headers"), this.resource.sortedRequestHeaders, this.requestHeadersTreeElement);
    285282        this._refreshFormData();
    286283    },
     
    288285    _refreshResponseHeaders: function()
    289286    {
    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);
     287        this._refreshHeaders(WebInspector.UIString("Response Headers"), this.resource.sortedResponseHeaders, this.responseHeadersTreeElement);
    294288    },
    295289
     
    322316    },
    323317   
    324     _refreshHeaders: function(title, headers, additionalRow, headersTreeElement)
     318    _refreshHeaders: function(title, headers, headersTreeElement)
    325319    {
    326320        headersTreeElement.removeChildren();
     
    339333            headersTreeElement.appendChild(headerTreeElement);
    340334        }
    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         }
    350335    }
    351336}
  • trunk/WebCore/inspector/front-end/inspector.css

    r64104 r64142  
    28202820
    28212821.resources-category-documents, .resources-category-stylesheets, .resources-category-images,
    2822 .resources-category-scripts, .resources-category-xhr, .resources-category-fonts,
    2823 .resources-category-websockets, .resources-category-other {
     2822.resources-category-scripts, .resources-category-xhr, .resources-category-fonts, .resources-category-other {
    28242823    display: none;
    28252824}
     
    28312830.filter-all .resources-category-xhr, .filter-xhr .resources-category-xhr,
    28322831.filter-all .resources-category-fonts, .filter-fonts .resources-category-fonts,
    2833 .filter-all .resources-category-websockets, .filter-websockets .resources-category-websockets,
    28342832.filter-all .resources-category-other, .filter-other .resources-category-other,
    28352833.resource-sidebar-tree-item.selected {
     
    29052903.resources-category-xhr.resource-cached .resources-graph-bar {
    29062904    -webkit-border-image: url(Images/timelineHollowPillYellow.png) 6 7 6 7;
    2907 }
    2908 
    2909 /* FIXME: Create bar images for WebSocket. */
    2910 .resources-category-websockets .resources-graph-bar {
    2911     -webkit-border-image: url(Images/timelinePillGray.png) 6 7 6 7;
    2912 }
    2913 
    2914 .resources-category-websockets.resource-cached .resources-graph-bar {
    2915    -webkit-border-image: url(Images/timelineHollowPillGray.png) 6 7 6 7;
    29162905}
    29172906
  • trunk/WebCore/inspector/front-end/inspector.js

    r64104 r64142  
    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.
    468467        other: new WebInspector.ResourceCategory("other", WebInspector.UIString("Other"), "rgb(186,186,186)")
    469468    };
     
    11651164        resource.requestFormData = payload.requestFormData;
    11661165        resource.documentURL = payload.documentURL;
    1167         if (typeof payload.webSocketRequestKey3 !== "undefined")
    1168             resource.webSocketRequestKey3 = payload.webSocketRequestKey3;
    11691166
    11701167        if (resource.mainResource)
     
    11911188        resource.timing = payload.timing;
    11921189        resource.cached = payload.cached;
    1193         if (typeof payload.webSocketChallengeResponse !== "undefined")
    1194             resource.webSocketChallengeResponse = payload.webSocketChallengeResponse;
    11951190    }
    11961191
  • trunk/WebCore/websockets/WebSocketChannel.cpp

    r64104 r64142  
    3737#include "CookieJar.h"
    3838#include "Document.h"
    39 #include "InspectorController.h"
    4039#include "Logging.h"
    41 #include "Page.h"
    4240#include "PlatformString.h"
    43 #include "ProgressTracker.h"
    4441#include "ScriptExecutionContext.h"
    4542#include "SocketStreamError.h"
     
    6663    , m_closed(false)
    6764    , m_unhandledBufferedAmount(0)
    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
     65{
    7666}
    7767
     
    122112{
    123113    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
    129114    m_handshake.clearScriptExecutionContext();
    130115    m_client = 0;
     
    152137    if (!m_context)
    153138        return;
    154 #if ENABLE(INSPECTOR)
    155     if (InspectorController* controller = m_context->inspectorController())
    156         controller->willSendWebSocketHandshakeRequest(identifier(), m_handshake.clientHandshakeRequest());
    157 #endif
    158139    const CString& handshakeMessage = m_handshake.clientHandshakeMessage();
    159140    if (!handle->send(handshakeMessage.data(), handshakeMessage.length())) {
     
    166147{
    167148    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
    173149    ASSERT_UNUSED(handle, handle == m_handle || !m_handle);
    174150    m_closed = true;
     
    262238            return false;
    263239        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
    268240            if (!m_handshake.serverSetCookie().isEmpty()) {
    269241                if (m_context->isDocument()) {
     
    357329}
    358330
    359 #if ENABLE(INSPECTOR)
    360 unsigned 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 
    374331}  // namespace WebCore
    375332
  • trunk/WebCore/websockets/WebSocketChannel.h

    r64104 r64142  
    8585        void resumeTimerFired(Timer<WebSocketChannel>* timer);
    8686
    87 #if ENABLE(INSPECTOR)
    88         unsigned long identifier();
    89 #endif
    90 
    9187        ScriptExecutionContext* m_context;
    9288        WebSocketChannelClient* m_client;
     
    10096        bool m_closed;
    10197        unsigned long m_unhandledBufferedAmount;
    102 
    103 #if ENABLE(INSPECTOR)
    104         unsigned long m_identifier;
    105 #endif
    10698    };
    10799
Note: See TracChangeset for help on using the changeset viewer.