Changeset 204512 in webkit


Ignore:
Timestamp:
Aug 16, 2016 10:14:42 AM (8 years ago)
Author:
achristensen@apple.com
Message:

Clean up WebSockets
https://bugs.webkit.org/show_bug.cgi?id=160889

Reviewed by Darin Adler.

Source/WebCore:

We should use size_t's instead of ints for data lengths.
SocketStreamHandleClient is now purely virtual.
A few places that will need SocketStreamHandleImpls instead of SocketStreamHandles now have them.
This patch doesn't change behavior.

  • Modules/websockets/WebSocketChannel.cpp:

(WebCore::WebSocketChannel::didCloseSocketStream):
(WebCore::WebSocketChannel::didReceiveSocketStreamData):

  • Modules/websockets/WebSocketChannel.h:
  • platform/network/SocketStreamHandle.cpp:

(WebCore::SocketStreamHandle::state):
(WebCore::SocketStreamHandle::send):

  • platform/network/SocketStreamHandle.h:

(WebCore::SocketStreamHandle::~SocketStreamHandle):
(WebCore::SocketStreamHandle::bufferedAmount):
(WebCore::SocketStreamHandle::client): Deleted.

  • platform/network/SocketStreamHandleClient.h:

(WebCore::SocketStreamHandleClient::~SocketStreamHandleClient):
(WebCore::SocketStreamHandleClient::didOpenSocketStream): Deleted.
(WebCore::SocketStreamHandleClient::didCloseSocketStream): Deleted.
(WebCore::SocketStreamHandleClient::didReceiveSocketStreamData): Deleted.
(WebCore::SocketStreamHandleClient::didUpdateBufferedAmount): Deleted.
(WebCore::SocketStreamHandleClient::didFailSocketStream): Deleted.

  • platform/network/cf/SocketStreamHandleImpl.h:

(WebCore::SocketStreamHandleImpl::create):

  • platform/network/cf/SocketStreamHandleImplCFNet.cpp:

(WebCore::SocketStreamHandleImpl::~SocketStreamHandleImpl):
(WebCore::SocketStreamHandleImpl::platformSend):
(WebCore::SocketStreamHandleImpl::platformClose):

  • platform/network/curl/SocketStreamHandleImpl.h:

(WebCore::SocketStreamHandleImpl::create):

  • platform/network/soup/SocketStreamHandleImpl.h:
  • platform/network/soup/SocketStreamHandleImplSoup.cpp:

(WebCore::SocketStreamHandleImpl::create):

Source/WebKit2:

  • UIProcess/InspectorServer/WebSocketServerConnection.cpp:

(WebKit::WebSocketServerConnection::didCloseSocketStream):
(WebKit::WebSocketServerConnection::didReceiveSocketStreamData):

  • UIProcess/InspectorServer/WebSocketServerConnection.h:
Location:
trunk/Source
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r204509 r204512  
     12016-08-16  Alex Christensen  <achristensen@webkit.org>
     2
     3        Clean up WebSockets
     4        https://bugs.webkit.org/show_bug.cgi?id=160889
     5
     6        Reviewed by Darin Adler.
     7
     8        We should use size_t's instead of ints for data lengths.
     9        SocketStreamHandleClient is now purely virtual.
     10        A few places that will need SocketStreamHandleImpls instead of SocketStreamHandles now have them.
     11        This patch doesn't change behavior.
     12
     13        * Modules/websockets/WebSocketChannel.cpp:
     14        (WebCore::WebSocketChannel::didCloseSocketStream):
     15        (WebCore::WebSocketChannel::didReceiveSocketStreamData):
     16        * Modules/websockets/WebSocketChannel.h:
     17        * platform/network/SocketStreamHandle.cpp:
     18        (WebCore::SocketStreamHandle::state):
     19        (WebCore::SocketStreamHandle::send):
     20        * platform/network/SocketStreamHandle.h:
     21        (WebCore::SocketStreamHandle::~SocketStreamHandle):
     22        (WebCore::SocketStreamHandle::bufferedAmount):
     23        (WebCore::SocketStreamHandle::client): Deleted.
     24        * platform/network/SocketStreamHandleClient.h:
     25        (WebCore::SocketStreamHandleClient::~SocketStreamHandleClient):
     26        (WebCore::SocketStreamHandleClient::didOpenSocketStream): Deleted.
     27        (WebCore::SocketStreamHandleClient::didCloseSocketStream): Deleted.
     28        (WebCore::SocketStreamHandleClient::didReceiveSocketStreamData): Deleted.
     29        (WebCore::SocketStreamHandleClient::didUpdateBufferedAmount): Deleted.
     30        (WebCore::SocketStreamHandleClient::didFailSocketStream): Deleted.
     31        * platform/network/cf/SocketStreamHandleImpl.h:
     32        (WebCore::SocketStreamHandleImpl::create):
     33        * platform/network/cf/SocketStreamHandleImplCFNet.cpp:
     34        (WebCore::SocketStreamHandleImpl::~SocketStreamHandleImpl):
     35        (WebCore::SocketStreamHandleImpl::platformSend):
     36        (WebCore::SocketStreamHandleImpl::platformClose):
     37        * platform/network/curl/SocketStreamHandleImpl.h:
     38        (WebCore::SocketStreamHandleImpl::create):
     39        * platform/network/soup/SocketStreamHandleImpl.h:
     40        * platform/network/soup/SocketStreamHandleImplSoup.cpp:
     41        (WebCore::SocketStreamHandleImpl::create):
     42
    1432016-08-16  Chris Dumez  <cdumez@apple.com>
    244
  • trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp

    r204466 r204512  
    309309}
    310310
    311 void WebSocketChannel::didReceiveSocketStreamData(SocketStreamHandle& handle, const char* data, int len)
    312 {
    313     LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received %d bytes", this, len);
     311void WebSocketChannel::didReceiveSocketStreamData(SocketStreamHandle& handle, const char* data, Optional<size_t> len)
     312{
     313    if (len)
     314        LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received %zu bytes", this, len.value());
     315    else
     316        LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received no bytes", this);
    314317    Ref<WebSocketChannel> protectedThis(*this); // The client can close the channel, potentially removing the last reference.
    315318    ASSERT(&handle == m_handle);
     
    317320        return;
    318321    }
    319     if (len <= 0) {
     322    if (!len || !len.value()) {
    320323        handle.disconnect();
    321324        return;
     
    328331    if (m_shouldDiscardReceivedData)
    329332        return;
    330     if (!appendToBuffer(data, len)) {
     333    if (!appendToBuffer(data, len.value())) {
    331334        m_shouldDiscardReceivedData = true;
    332335        fail("Ran out of memory while receiving WebSocket data.");
    333336        return;
    334337    }
    335     while (!m_suspended && m_client && !m_buffer.isEmpty())
     338    while (!m_suspended && m_client && !m_buffer.isEmpty()) {
    336339        if (!processBuffer())
    337340            break;
     341    }
    338342}
    339343
  • trunk/Source/WebCore/Modules/websockets/WebSocketChannel.h

    r204465 r204512  
    8181
    8282    // SocketStreamHandleClient functions.
    83     void didOpenSocketStream(SocketStreamHandle&) override;
    84     void didCloseSocketStream(SocketStreamHandle&) override;
    85     void didReceiveSocketStreamData(SocketStreamHandle&, const char*, int) override;
    86     void didUpdateBufferedAmount(SocketStreamHandle&, size_t bufferedAmount) override;
    87     void didFailSocketStream(SocketStreamHandle&, const SocketStreamError&) override;
     83    void didOpenSocketStream(SocketStreamHandle&) final;
     84    void didCloseSocketStream(SocketStreamHandle&) final;
     85    void didReceiveSocketStreamData(SocketStreamHandle&, const char*, Optional<size_t>) final;
     86    void didUpdateBufferedAmount(SocketStreamHandle&, size_t bufferedAmount) final;
     87    void didFailSocketStream(SocketStreamHandle&, const SocketStreamError&) final;
    8888
    8989    enum CloseEventCode {
  • trunk/Source/WebCore/platform/network/SocketStreamHandle.cpp

    r204483 r204512  
    5050}
    5151
    52 bool SocketStreamHandle::send(const char* data, int length)
     52bool SocketStreamHandle::send(const char* data, size_t length)
    5353{
    5454    if (m_state == Connecting || m_state == Closing)
     
    6363        return true;
    6464    }
    65     int bytesWritten = 0;
    66     if (m_state == Open)
    67         bytesWritten = platformSend(data, length);
    68     if (bytesWritten < 0)
    69         return false;
     65    size_t bytesWritten = 0;
     66    if (m_state == Open) {
     67        if (auto result = platformSend(data, length))
     68            bytesWritten = result.value();
     69        else
     70            return false;
     71    }
    7072    if (m_buffer.size() + length - bytesWritten > bufferSize) {
    7173        // FIXME: report error to indicate that buffer has no more space.
     
    111113    bool pending;
    112114    do {
    113         int bytesWritten = platformSend(m_buffer.firstBlockData(), m_buffer.firstBlockSize());
    114         pending = bytesWritten != static_cast<int>(m_buffer.firstBlockSize());
    115         if (bytesWritten <= 0)
     115        auto result = platformSend(m_buffer.firstBlockData(), m_buffer.firstBlockSize());
     116        if (!result)
    116117            return false;
     118        size_t bytesWritten = result.value();
     119        if (!bytesWritten)
     120            return false;
     121        pending = bytesWritten != m_buffer.firstBlockSize();
    117122        ASSERT(m_buffer.size() - bytesWritten <= bufferSize);
    118123        m_buffer.consume(bytesWritten);
  • trunk/Source/WebCore/platform/network/SocketStreamHandle.h

    r204483 r204512  
    4646    SocketStreamState state() const;
    4747
    48     bool send(const char* data, int length);
     48    bool send(const char* data, size_t length);
    4949    void close(); // Disconnect after all data in buffer are sent.
    5050    void disconnect();
    5151    size_t bufferedAmount() const { return m_buffer.size(); }
    52 
    53     SocketStreamHandleClient& client() const { return m_client; }
    5452
    5553protected:
     
    5755
    5856    bool sendPendingData();
    59     virtual int platformSend(const char* data, int length) = 0;
     57    virtual Optional<size_t> platformSend(const char* data, size_t length) = 0;
    6058    virtual void platformClose() = 0;
    6159
  • trunk/Source/WebCore/platform/network/SocketStreamHandleClient.h

    r204465 r204512  
    3232#pragma once
    3333
     34#include <wtf/Optional.h>
     35
    3436namespace WebCore {
    3537
     
    4143    virtual ~SocketStreamHandleClient() { }
    4244
    43     virtual void didOpenSocketStream(SocketStreamHandle&) { }
    44     virtual void didCloseSocketStream(SocketStreamHandle&) { }
    45     virtual void didReceiveSocketStreamData(SocketStreamHandle&, const char* /*data*/, int /*length*/) { }
    46     virtual void didUpdateBufferedAmount(SocketStreamHandle&, size_t /*bufferedAmount*/) { }
    47 
    48     virtual void didFailSocketStream(SocketStreamHandle&, const SocketStreamError&) { }
     45    virtual void didOpenSocketStream(SocketStreamHandle&) = 0;
     46    virtual void didCloseSocketStream(SocketStreamHandle&) = 0;
     47    virtual void didReceiveSocketStreamData(SocketStreamHandle&, const char* data, Optional<size_t> length) = 0;
     48    virtual void didUpdateBufferedAmount(SocketStreamHandle&, size_t bufferedAmount) = 0;
     49    virtual void didFailSocketStream(SocketStreamHandle&, const SocketStreamError&) = 0;
    4950};
    5051
  • trunk/Source/WebCore/platform/network/cf/SocketStreamHandleImpl.h

    r204483 r204512  
    4646class SocketStreamHandleImpl : public SocketStreamHandle {
    4747public:
    48     static Ref<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient& client, SessionID sessionID) { return adoptRef(*new SocketStreamHandleImpl(url, client, sessionID)); }
     48    static Ref<SocketStreamHandleImpl> create(const URL& url, SocketStreamHandleClient& client, SessionID sessionID) { return adoptRef(*new SocketStreamHandleImpl(url, client, sessionID)); }
    4949
    5050    virtual ~SocketStreamHandleImpl();
    5151
    5252private:
    53     virtual int platformSend(const char* data, int length);
     53    virtual Optional<size_t> platformSend(const char* data, size_t length);
    5454    virtual void platformClose();
    5555
  • trunk/Source/WebCore/platform/network/cf/SocketStreamHandleImplCFNet.cpp

    r204483 r204512  
    537537            return;
    538538
    539         m_client.didReceiveSocketStreamData(*this, reinterpret_cast<const char*>(ptr), length);
     539        Optional<size_t> optionalLength;
     540        if (length != -1)
     541            optionalLength = length;
     542       
     543        m_client.didReceiveSocketStreamData(*this, reinterpret_cast<const char*>(ptr), optionalLength);
    540544
    541545        return;
     
    650654}
    651655
    652 int SocketStreamHandleImpl::platformSend(const char* data, int length)
     656Optional<size_t> SocketStreamHandleImpl::platformSend(const char* data, size_t length)
    653657{
    654658    if (!CFWriteStreamCanAcceptBytes(m_writeStream.get()))
    655         return 0;
    656 
    657     return CFWriteStreamWrite(m_writeStream.get(), reinterpret_cast<const UInt8*>(data), length);
     659        return Nullopt;
     660
     661    CFIndex result = CFWriteStreamWrite(m_writeStream.get(), reinterpret_cast<const UInt8*>(data), length);
     662    if (result == -1)
     663        return Nullopt;
     664
     665    ASSERT(result >= 0);
     666    return static_cast<size_t>(result);
    658667}
    659668
  • trunk/Source/WebCore/platform/network/curl/SocketStreamHandleImpl.h

    r204483 r204512  
    5151class SocketStreamHandleImpl : public SocketStreamHandle {
    5252public:
    53     static Ref<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient& client, SessionID) { return adoptRef(*new SocketStreamHandleImpl(url, client)); }
     53    static Ref<SocketStreamHandleImpl> create(const URL& url, SocketStreamHandleClient& client, SessionID) { return adoptRef(*new SocketStreamHandleImpl(url, client)); }
    5454
    5555    virtual ~SocketStreamHandleImpl();
     
    5858    SocketStreamHandleImpl(const URL&, SocketStreamHandleClient&);
    5959
    60     int platformSend(const char* data, int length) override;
    61     void platformClose() override;
     60    Optional<size_t> platformSend(const char* data, size_t length) final;
     61    void platformClose() final;
    6262
    6363    bool readData(CURL*);
     
    7171    void didOpenSocket();
    7272
    73     static std::unique_ptr<char[]> createCopy(const char* data, int length);
     73    static std::unique_ptr<char[]> createCopy(const char* data, size_t length);
    7474
    7575    struct SocketData {
    76         SocketData(std::unique_ptr<char[]>&& source, int length)
     76        SocketData(std::unique_ptr<char[]>&& source, size_t length)
    7777        {
    7878            data = WTFMove(source);
     
    8888
    8989        std::unique_ptr<char[]> data;
    90         int size { 0 };
     90        size_t size { 0 };
    9191    };
    9292
  • trunk/Source/WebCore/platform/network/curl/SocketStreamHandleImplCurl.cpp

    r204483 r204512  
    5959}
    6060
    61 int SocketStreamHandleImpl::platformSend(const char* data, int length)
     61Optional<size_t> SocketStreamHandleImpl::platformSend(const char* data, size_t length)
    6262{
    6363    LOG(Network, "SocketStreamHandle %p platformSend", this);
     
    9090    ASSERT(!isMainThread());
    9191
    92     const int bufferSize = 1024;
     92    const size_t bufferSize = 1024;
    9393    std::unique_ptr<char[]> data(new char[bufferSize]);
    9494    size_t bytesRead = 0;
     
    9898    if (ret == CURLE_OK && bytesRead >= 0) {
    9999        m_mutexReceive.lock();
    100         m_receiveData.append(SocketData { WTFMove(data), static_cast<int>(bytesRead) });
     100        m_receiveData.append(SocketData { WTFMove(data), bytesRead });
    101101        m_mutexReceive.unlock();
    102102
     
    131131        m_mutexSend.unlock();
    132132
    133         int totalBytesSent = 0;
     133        size_t totalBytesSent = 0;
    134134        while (totalBytesSent < sendData.size) {
    135135            size_t bytesSent = 0;
     
    144144
    145145        if (totalBytesSent < sendData.size) {
    146             const int restLength = sendData.size - totalBytesSent;
     146            const size_t restLength = sendData.size - totalBytesSent;
    147147            auto copy = createCopy(sendData.data.get() + totalBytesSent, restLength);
    148148
  • trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImpl.h

    r204483 r204512  
    4848class SocketStreamHandleImpl final : public SocketStreamHandle {
    4949public:
    50     static Ref<SocketStreamHandle> create(const URL&, SocketStreamHandleClient&, SessionID);
     50    static Ref<SocketStreamHandleImpl> create(const URL&, SocketStreamHandleClient&, SessionID);
    5151    static Ref<SocketStreamHandle> create(GSocketConnection*, SocketStreamHandleClient&);
    5252
     
    5656    SocketStreamHandleImpl(const URL&, SocketStreamHandleClient&);
    5757
    58     int platformSend(const char* data, int length) override;
    59     void platformClose() override;
     58    Optional<size_t> platformSend(const char* data, size_t length) final;
     59    void platformClose() final;
    6060
    6161    void beginWaitingForSocketWritability();
  • trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp

    r204501 r204512  
    4949namespace WebCore {
    5050
    51 Ref<SocketStreamHandle> SocketStreamHandleImpl::create(const URL& url, SocketStreamHandleClient& client, SessionID)
     51Ref<SocketStreamHandleImpl> SocketStreamHandleImpl::create(const URL& url, SocketStreamHandleClient& client, SessionID)
    5252{
    5353    Ref<SocketStreamHandleImpl> socket = adoptRef(*new SocketStreamHandleImpl(url, client));
     
    6060    g_socket_client_connect_to_host_async(socketClient.get(), url.host().utf8().data(), port, socket->m_cancellable.get(),
    6161        reinterpret_cast<GAsyncReadyCallback>(connectedCallback), &protectedSocketStreamHandle.leakRef());
    62     return WTFMove(socket);
     62    return socket;
    6363}
    6464
     
    129129    // The client can close the handle, potentially removing the last reference.
    130130    RefPtr<SocketStreamHandle> protectedThis(this);
    131     m_client.didReceiveSocketStreamData(*this, m_readBuffer.get(), bytesRead);
     131    Optional<size_t> optionalLength;
     132    if (bytesRead != -1)
     133        optionalLength = static_cast<size_t>(bytesRead);
     134    m_client.didReceiveSocketStreamData(*this, m_readBuffer.get(), optionalLength);
    132135    if (m_inputStream) {
    133136        g_input_stream_read_async(m_inputStream.get(), m_readBuffer.get(), READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, m_cancellable.get(),
     
    169172}
    170173
    171 int SocketStreamHandleImpl::platformSend(const char* data, int length)
     174Optional<size_t> SocketStreamHandleImpl::platformSend(const char* data, size_t length)
    172175{
    173176    LOG(Network, "SocketStreamHandle %p platformSend", this);
    174177    if (!m_outputStream || !data)
    175         return 0;
     178        return Nullopt;
    176179
    177180    GUniqueOutPtr<GError> error;
     
    182185        else
    183186            didFail(SocketStreamError(error->code, String(), error->message));
    184         return 0;
     187        return Nullopt;
    185188    }
    186189
    187190    // If we did not send all the bytes we were given, we know that
    188191    // SocketStreamHandle will need to send more in the future.
    189     if (written < length)
     192    if (written == -1 || static_cast<size_t>(written) < length)
    190193        beginWaitingForSocketWritability();
    191194
    192     return written;
     195    if (written == -1)
     196        return Nullopt;
     197
     198    return static_cast<size_t>(written);
    193199}
    194200
  • trunk/Source/WebKit2/ChangeLog

    r204509 r204512  
     12016-08-16  Alex Christensen  <achristensen@webkit.org>
     2
     3        Clean up WebSockets
     4        https://bugs.webkit.org/show_bug.cgi?id=160889
     5
     6        Reviewed by Darin Adler.
     7
     8        * UIProcess/InspectorServer/WebSocketServerConnection.cpp:
     9        (WebKit::WebSocketServerConnection::didCloseSocketStream):
     10        (WebKit::WebSocketServerConnection::didReceiveSocketStreamData):
     11        * UIProcess/InspectorServer/WebSocketServerConnection.h:
     12
    1132016-08-16  Chris Dumez  <cdumez@apple.com>
    214
  • trunk/Source/WebKit2/UIProcess/InspectorServer/WebSocketServerConnection.cpp

    r202367 r204512  
    134134}
    135135
    136 void WebSocketServerConnection::didReceiveSocketStreamData(SocketStreamHandle&, const char* data, int length)
     136void WebSocketServerConnection::didReceiveSocketStreamData(SocketStreamHandle&, const char* data, Optional<size_t> length)
    137137{
    138138    // Each didReceiveData call adds more data to our buffer.
    139139    // We clear the buffer when we have handled data from it.
    140     m_bufferedData.append(data, length);
     140    if (length)
     141        m_bufferedData.append(data, length.value());
    141142
    142143    switch (m_mode) {
  • trunk/Source/WebKit2/UIProcess/InspectorServer/WebSocketServerConnection.h

    r202367 r204512  
    2525 */
    2626
    27 #ifndef WebSocketServerConnection_h
    28 #define WebSocketServerConnection_h
     27#pragma once
    2928
    3029#if ENABLE(INSPECTOR_SERVER)
     
    3837namespace WebCore {
    3938class HTTPHeaderMap;
     39class SocketStreamError;
    4040class SocketStreamHandle;
    4141}
     
    6868private:
    6969    // SocketStreamHandleClient implementation.
    70     void didCloseSocketStream(WebCore::SocketStreamHandle&) override;
    71     void didReceiveSocketStreamData(WebCore::SocketStreamHandle&, const char* data, int length) override;
    72     void didUpdateBufferedAmount(WebCore::SocketStreamHandle&, size_t bufferedAmount) override;
     70    void didOpenSocketStream(WebCore::SocketStreamHandle&) final { }
     71    void didCloseSocketStream(WebCore::SocketStreamHandle&) final;
     72    void didReceiveSocketStreamData(WebCore::SocketStreamHandle&, const char* data, Optional<size_t> length) final;
     73    void didUpdateBufferedAmount(WebCore::SocketStreamHandle&, size_t bufferedAmount) final;
     74    void didFailSocketStream(WebCore::SocketStreamHandle&, const WebCore::SocketStreamError&) final { }
    7375
    7476    // HTTP Mode.
     
    9294
    9395#endif // ENABLE(INSPECTOR_SERVER)
    94 
    95 #endif // WebSocketServerConnection_h
Note: See TracChangeset for help on using the changeset viewer.