⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 267370 in webkit


Ignore:
Timestamp:
Sep 21, 2020, 2:45:23 PM (6 years ago)
Author:
basuke.suzuki@sony.com
Message:

[WinCairo][PlayStation] Support different instances of listener client.
​https://bugs.webkit.org/show_bug.cgi?id=216733

Reviewed by Don Olmstead.

Source/JavaScriptCore:

Currently RemoteInspectorSocketEndpoint support one client instance for all
listeners. This patch allows listeners to create its own listener client on
accept timing.

  • inspector/remote/RemoteControllableTarget.h:
  • inspector/remote/RemoteInspector.h:
  • inspector/remote/socket/RemoteInspectorConnectionClient.cpp:

(Inspector::RemoteInspectorConnectionClient::didReceive):

  • inspector/remote/socket/RemoteInspectorConnectionClient.h:
  • inspector/remote/socket/RemoteInspectorServer.cpp:

(Inspector::RemoteInspectorServer::start):
(Inspector::RemoteInspectorServer::doAccept):

  • inspector/remote/socket/RemoteInspectorServer.h:
  • inspector/remote/socket/RemoteInspectorSocket.cpp:

(Inspector::RemoteInspector::didClose):

  • inspector/remote/socket/RemoteInspectorSocket.h:
  • inspector/remote/socket/RemoteInspectorSocketEndpoint.cpp:

(Inspector::RemoteInspectorSocketEndpoint::RemoteInspectorSocketEndpoint):
(Inspector::RemoteInspectorSocketEndpoint::~RemoteInspectorSocketEndpoint):
(Inspector::RemoteInspectorSocketEndpoint::listenInet):
(Inspector::RemoteInspectorSocketEndpoint::workerThread):
(Inspector::RemoteInspectorSocketEndpoint::generateConnectionID):
(Inspector::RemoteInspectorSocketEndpoint::createClient):
(Inspector::RemoteInspectorSocketEndpoint::disconnect):
(Inspector::RemoteInspectorSocketEndpoint::createListener):
(Inspector::RemoteInspectorSocketEndpoint::invalidateClient):
(Inspector::RemoteInspectorSocketEndpoint::invalidateListener):
(Inspector::RemoteInspectorSocketEndpoint::getPort const):
(Inspector::RemoteInspectorSocketEndpoint::recvIfEnabled):
(Inspector::RemoteInspectorSocketEndpoint::sendIfEnabled):
(Inspector::RemoteInspectorSocketEndpoint::send):
(Inspector::RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled):

  • inspector/remote/socket/RemoteInspectorSocketEndpoint.h:

Source/WebKit:

Follows the change of RemoteInspectorSocketEndpoint::Client interface change.

No new tests because there's no behaivior change.

  • UIProcess/Inspector/socket/RemoteInspectorClient.cpp:

(WebKit::RemoteInspectorClient::didClose):

  • UIProcess/Inspector/socket/RemoteInspectorClient.h:
Location:
trunk/Source
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r267364 r267370  
     12020-09-21  Basuke Suzuki  <basuke.suzuki@sony.com>
     2
     3        [WinCairo][PlayStation] Support different instances of listener client.
     4        https://bugs.webkit.org/show_bug.cgi?id=216733
     5
     6        Reviewed by Don Olmstead.
     7
     8        Currently RemoteInspectorSocketEndpoint support one client instance for all
     9        listeners. This patch allows listeners to create its own listener client on
     10        accept timing.
     11
     12        * inspector/remote/RemoteControllableTarget.h:
     13        * inspector/remote/RemoteInspector.h:
     14        * inspector/remote/socket/RemoteInspectorConnectionClient.cpp:
     15        (Inspector::RemoteInspectorConnectionClient::didReceive):
     16        * inspector/remote/socket/RemoteInspectorConnectionClient.h:
     17        * inspector/remote/socket/RemoteInspectorServer.cpp:
     18        (Inspector::RemoteInspectorServer::start):
     19        (Inspector::RemoteInspectorServer::doAccept):
     20        * inspector/remote/socket/RemoteInspectorServer.h:
     21        * inspector/remote/socket/RemoteInspectorSocket.cpp:
     22        (Inspector::RemoteInspector::didClose):
     23        * inspector/remote/socket/RemoteInspectorSocket.h:
     24        * inspector/remote/socket/RemoteInspectorSocketEndpoint.cpp:
     25        (Inspector::RemoteInspectorSocketEndpoint::RemoteInspectorSocketEndpoint):
     26        (Inspector::RemoteInspectorSocketEndpoint::~RemoteInspectorSocketEndpoint):
     27        (Inspector::RemoteInspectorSocketEndpoint::listenInet):
     28        (Inspector::RemoteInspectorSocketEndpoint::workerThread):
     29        (Inspector::RemoteInspectorSocketEndpoint::generateConnectionID):
     30        (Inspector::RemoteInspectorSocketEndpoint::createClient):
     31        (Inspector::RemoteInspectorSocketEndpoint::disconnect):
     32        (Inspector::RemoteInspectorSocketEndpoint::createListener):
     33        (Inspector::RemoteInspectorSocketEndpoint::invalidateClient):
     34        (Inspector::RemoteInspectorSocketEndpoint::invalidateListener):
     35        (Inspector::RemoteInspectorSocketEndpoint::getPort const):
     36        (Inspector::RemoteInspectorSocketEndpoint::recvIfEnabled):
     37        (Inspector::RemoteInspectorSocketEndpoint::sendIfEnabled):
     38        (Inspector::RemoteInspectorSocketEndpoint::send):
     39        (Inspector::RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled):
     40        * inspector/remote/socket/RemoteInspectorSocketEndpoint.h:
     41
    1422020-09-21  Keith Miller  <keith_miller@apple.com>
    243

  • trunk/Source/JavaScriptCore/inspector/remote/RemoteControllableTarget.h

    r262302 r267370  
    2828#if ENABLE(REMOTE_INSPECTOR)
    2929
     30#include "JSExportMacros.h"
    3031#include <wtf/TypeCasts.h>
    3132#include <wtf/text/WTFString.h>

  • trunk/Source/JavaScriptCore/inspector/remote/RemoteInspector.h

    r265276 r267370  
    8080{
    8181public:
    82     class Client {
     82    class JS_EXPORT_PRIVATE Client {
    8383    public:
    8484        struct Capabilities {
    … …  
    225225#if USE(INSPECTOR_SOCKET_SERVER)
    226226    HashMap<String, CallHandler>& dispatchMap() final;
    227     void didClose(ConnectionID) final;
     227    void didClose(RemoteInspectorSocketEndpoint&, ConnectionID) final;
    228228
    229229    void sendWebInspectorEvent(const String&);

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorConnectionClient.cpp

    r266885 r267370  
    6363}
    6464
    65 void RemoteInspectorConnectionClient::didReceive(ConnectionID clientID, Vector<uint8_t>&& data)
     65void RemoteInspectorConnectionClient::didReceive(RemoteInspectorSocketEndpoint&, ConnectionID clientID, Vector<uint8_t>&& data)
    6666{
    6767    ASSERT(!isMainThread());

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorConnectionClient.h

    r250988 r267370  
    4747    void send(ConnectionID, const uint8_t* data, size_t);
    4848
    49     void didReceive(ConnectionID, Vector<uint8_t>&&) override;
     49    void didReceive(RemoteInspectorSocketEndpoint&, ConnectionID, Vector<uint8_t>&&) override;
    5050
    5151    struct Event {

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorServer.cpp

    r265276 r267370  
    5656
    5757    auto& endpoint = Inspector::RemoteInspectorSocketEndpoint::singleton();
    58     m_server = endpoint.listenInet(address, port, *this, RemoteInspector::singleton());
     58    m_server = endpoint.listenInet(address, port, *this);
    5959    return isRunning();
    6060}
    … …  
    6969}
    7070
    71 bool RemoteInspectorServer::didAccept(ConnectionID acceptedID, ConnectionID, Socket::Domain)
     71Optional<ConnectionID> RemoteInspectorServer::doAccept(RemoteInspectorSocketEndpoint& endpoint, PlatformSocketType socket)
    7272{
    7373    ASSERT(!isMainThread());
    … …  
    7676    if (inspector.isConnected()) {
    7777        LOG_ERROR("RemoteInspector can accept only 1 client");
     78        return WTF::nullopt;
     79    }
    7880
    79         return false;
     81    if (auto newID = endpoint.createClient(socket, inspector)) {
     82        inspector.connect(newID.value());
     83        return newID;
    8084    }
    81     inspector.connect(acceptedID);
    82     return true;
     85
     86    return WTF::nullopt;
    8387}
    8488

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorServer.h

    r265276 r267370  
    4747    RemoteInspectorServer() { Socket::init(); }
    4848
    49     bool didAccept(ConnectionID acceptedID, ConnectionID listenerID, Socket::Domain) final;
    50     void didClose(ConnectionID) final { }
     49    Optional<ConnectionID> doAccept(RemoteInspectorSocketEndpoint&, PlatformSocketType) final;
     50    void didClose(RemoteInspectorSocketEndpoint&, ConnectionID) final { };
    5151
    5252    Optional<ConnectionID> m_server;

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorSocket.cpp

    r266885 r267370  
    6464}
    6565
    66 void RemoteInspector::didClose(ConnectionID)
     66void RemoteInspector::didClose(RemoteInspectorSocketEndpoint&, ConnectionID)
    6767{
    6868    ASSERT(isConnected());

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorSocket.h

    r253281 r267370  
    2828#if ENABLE(REMOTE_INSPECTOR)
    2929
     30#include "JSExportMacros.h"
    3031#include <array>
    3132#include <wtf/Optional.h>
    … …  
    6566void init();
    6667
    67 Optional<PlatformSocketType> connect(const char* serverAddress, uint16_t serverPort);
    68 Optional<PlatformSocketType> listen(const char* address, uint16_t port);
    69 Optional<PlatformSocketType> accept(PlatformSocketType);
    70 Optional<std::array<PlatformSocketType, 2>> createPair();
     68JS_EXPORT_PRIVATE Optional<PlatformSocketType> connect(const char* serverAddress, uint16_t serverPort);
     69JS_EXPORT_PRIVATE Optional<PlatformSocketType> listen(const char* address, uint16_t port);
     70JS_EXPORT_PRIVATE Optional<PlatformSocketType> accept(PlatformSocketType);
     71JS_EXPORT_PRIVATE Optional<std::array<PlatformSocketType, 2>> createPair();
    7172
    72 bool setup(PlatformSocketType);
    73 bool isValid(PlatformSocketType);
    74 bool isListening(PlatformSocketType);
    75 Optional<uint16_t> getPort(PlatformSocketType);
     73JS_EXPORT_PRIVATE bool setup(PlatformSocketType);
     74JS_EXPORT_PRIVATE bool isValid(PlatformSocketType);
     75JS_EXPORT_PRIVATE bool isListening(PlatformSocketType);
     76JS_EXPORT_PRIVATE Optional<uint16_t> getPort(PlatformSocketType);
    7677
    77 Optional<size_t> read(PlatformSocketType, void* buffer, int bufferSize);
    78 Optional<size_t> write(PlatformSocketType, const void* data, int size);
     78JS_EXPORT_PRIVATE Optional<size_t> read(PlatformSocketType, void* buffer, int bufferSize);
     79JS_EXPORT_PRIVATE Optional<size_t> write(PlatformSocketType, const void* data, int size);
    7980
    80 void close(PlatformSocketType&);
     81JS_EXPORT_PRIVATE void close(PlatformSocketType&);
    8182
    8283PollingDescriptor preparePolling(PlatformSocketType);

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorSocketEndpoint.cpp

    r265276 r267370  
    4848RemoteInspectorSocketEndpoint::RemoteInspectorSocketEndpoint()
    4949{
     50    Socket::init();
     51
    5052    if (auto sockets = Socket::createPair()) {
    5153        m_wakeupSendSocket = sockets->at(0);
    … …  
    6870    Socket::close(m_wakeupSendSocket);
    6971    Socket::close(m_wakeupReceiveSocket);
    70     for (const auto& connection : m_connections.values())
     72    for (const auto& connection : m_clients.values())
    7173        Socket::close(connection->socket);
    7274    for (const auto& connection : m_listeners.values())
    … …  
    8789}
    8890
    89 Optional<ConnectionID> RemoteInspectorSocketEndpoint::listenInet(const char* address, uint16_t port, Listener& listener, Client& client)
     91Optional<ConnectionID> RemoteInspectorSocketEndpoint::listenInet(const char* address, uint16_t port, Listener& listener)
    9092{
    9193    if (auto socket = Socket::listen(address, port))
    92         return createListener(*socket, listener, client);
     94        return createListener(*socket, listener);
    9395
    9496    return WTF::nullopt;
    … …  
    122124        {
    123125            LockHolder lock(m_connectionsLock);
    124             for (const auto& connection : m_connections) {
     126            for (const auto& connection : m_clients) {
    125127                pollfds.append(connection.value->poll);
    126128                ids.append(connection.key);
    … …  
    167169    do {
    168170        id = cryptographicallyRandomNumber();
    169     } while (!id || m_connections.contains(id) || m_listeners.contains(id));
     171    } while (!id || m_clients.contains(id) || m_listeners.contains(id));
    170172
    171173    return id;
    172174}
    173175
    174 std::unique_ptr<RemoteInspectorSocketEndpoint::Connection> RemoteInspectorSocketEndpoint::makeConnection(PlatformSocketType socket, Client& client)
    175 {
    176     ASSERT(m_connectionsLock.isLocked());
    177 
    178     Socket::setup(socket);
    179 
    180     auto connection = makeUnique<Connection>(client);
    181 
    182     connection->id = generateConnectionID();
    183     connection->poll = Socket::preparePolling(socket);
    184     connection->socket = socket;
    185 
    186     return connection;
    187 }
    188 
    189176Optional<ConnectionID> RemoteInspectorSocketEndpoint::createClient(PlatformSocketType socket, Client& client)
    190177{
    191     if (!Socket::isValid(socket))
    192         return WTF::nullopt;
    193 
    194     LockHolder lock(m_connectionsLock);
    195     auto connection = makeConnection(socket, client);
    196     auto id = connection->id;
    197     m_connections.add(id, WTFMove(connection));
     178    ASSERT(Socket::isValid(socket));
     179
     180    LockHolder lock(m_connectionsLock);
     181    auto id = generateConnectionID();
     182    auto connection = makeUnique<ClientConnection>(id, socket, client);
     183    m_clients.add(id, WTFMove(connection));
    198184    wakeupWorkerThread();
    199185
    … …  
    201187}
    202188
    203 Optional<ConnectionID> RemoteInspectorSocketEndpoint::createListener(PlatformSocketType socket, Listener& listener, Client& client)
    204 {
    205     if (!Socket::isValid(socket))
    206         return WTF::nullopt;
    207 
    208     LockHolder lock(m_connectionsLock);
     189void RemoteInspectorSocketEndpoint::disconnect(ConnectionID id)
     190{
     191    LockHolder lock(m_connectionsLock);
     192
     193    if (const auto& connection = m_listeners.get(id)) {
     194        m_listeners.remove(id);
     195        Socket::close(connection->socket);
     196        lock.unlockEarly();
     197        connection->listener.didClose(*this, id);
     198    } else if (const auto& connection = m_clients.get(id)) {
     199        m_clients.remove(id);
     200        Socket::close(connection->socket);
     201        lock.unlockEarly();
     202        connection->client.didClose(*this, id);
     203    } else
     204        LOG_ERROR("Error: Cannot disconnect: Invalid id");
     205}
     206
     207Optional<ConnectionID> RemoteInspectorSocketEndpoint::createListener(PlatformSocketType socket, Listener& listener)
     208{
     209    ASSERT(Socket::isValid(socket));
    209210
    210211    if (!Socket::setup(socket))
    211212        return WTF::nullopt;
    212213
    213     auto connection = makeConnection(socket, client);
    214     auto id = connection->id;
    215     connection->listener = &listener;
     214    LockHolder lock(m_connectionsLock);
     215    auto id = generateConnectionID();
     216    auto connection = makeUnique<ListenerConnection>(id, socket, listener);
    216217    m_listeners.add(id, WTFMove(connection));
    217218    wakeupWorkerThread();
    … …  
    220221}
    221222
     223Optional<ConnectionID> RemoteInspectorSocketEndpoint::createListener(PlatformSocketType socket, Listener& listener, Client& client)
     224{
     225    ASSERT(Socket::isValid(socket));
     226
     227    if (!Socket::setup(socket))
     228        return WTF::nullopt;
     229
     230    LockHolder lock(m_connectionsLock);
     231    auto id = generateConnectionID();
     232    auto connection = makeUnique<ListenerConnection>(id, socket, listener);
     233    m_listeners.add(id, WTFMove(connection));
     234    wakeupWorkerThread();
     235
     236    return id;
     237}
     238
    222239void RemoteInspectorSocketEndpoint::invalidateClient(Client& client)
    223240{
    224241    LockHolder lock(m_connectionsLock);
    225     m_connections.removeIf([&client](auto& keyValue) {
     242    m_clients.removeIf([&client](auto& keyValue) {
    226243        const auto& connection = keyValue.value;
    227244
    … …  
    241258        const auto& connection = keyValue.value;
    242259
    243         if (connection->listener == &listener) {
     260        if (&connection->listener == &listener) {
    244261            Socket::close(connection->socket);
    245262            return true;
    … …  
    255272    if (const auto& connection = m_listeners.get(id))
    256273        return Socket::getPort(connection->socket);
    257     if (const auto& connection = m_connections.get(id))
     274    if (const auto& connection = m_clients.get(id))
    258275        return Socket::getPort(connection->socket);
    259276
    … …  
    264281{
    265282    LockHolder lock(m_connectionsLock);
    266     if (const auto& connection = m_connections.get(id)) {
     283    if (const auto& connection = m_clients.get(id)) {
    267284        Vector<uint8_t> recvBuffer(Socket::BufferSize);
    268285        if (auto readSize = Socket::read(connection->socket, recvBuffer.data(), recvBuffer.size())) {
    269286            if (*readSize > 0) {
    270287                recvBuffer.shrink(*readSize);
    271                 connection->client.didReceive(id, WTFMove(recvBuffer));
     288                lock.unlockEarly();
     289                connection->client.didReceive(*this, id, WTFMove(recvBuffer));
    272290                return;
    273291            }
    … …  
    275293
    276294        Socket::close(connection->socket);
    277         m_connections.remove(id);
     295        m_clients.remove(id);
    278296
    279297        lock.unlockEarly();
    280         connection->client.didClose(id);
     298        connection->client.didClose(*this, id);
    281299    }
    282300}
    … …  
    285303{
    286304    LockHolder lock(m_connectionsLock);
    287     if (const auto& connection = m_connections.get(id)) {
     305    if (const auto& connection = m_clients.get(id)) {
    288306        Socket::clearWaitingWritable(connection->poll);
    289307
    … …  
    310328{
    311329    LockHolder lock(m_connectionsLock);
    312     if (const auto& connection = m_connections.get(id)) {
     330    if (const auto& connection = m_clients.get(id)) {
    313331        size_t offset = 0;
    314332        if (connection->sendBuffer.isEmpty()) {
    … …  
    340358            // Need to unlock before calling createClient as it also attempts to lock.
    341359            lock.unlockEarly();
    342             if (auto newID = createClient(*socket, connection->client)) {
    343                 if (connection->listener->didAccept(newID.value(), connection->id, Socket::Domain::Network))
    344                     return;
    345 
    346                 m_connections.remove(id);
    347             }
    348 
     360            if (connection->listener.doAccept(*this, socket.value()))
     361                return;
    349362            Socket::close(*socket);
    350363        }

  • trunk/Source/JavaScriptCore/inspector/remote/socket/RemoteInspectorSocketEndpoint.h

    r250988 r267370  
    2929
    3030#include "RemoteInspectorSocket.h"
    31 
    3231#include <wtf/Condition.h>
    3332#include <wtf/Function.h>
    … …  
    3938namespace Inspector {
    4039
    41 class RemoteInspectorSocketEndpoint {
     40class JS_EXPORT_PRIVATE RemoteInspectorSocketEndpoint {
    4241    WTF_MAKE_FAST_ALLOCATED;
    4342public:
    4443    class Client {
    4544    public:
    46         virtual void didReceive(ConnectionID, Vector<uint8_t>&&) = 0;
    47         virtual void didClose(ConnectionID) = 0;
     45        virtual ~Client() { }
     46        virtual void didReceive(RemoteInspectorSocketEndpoint&, ConnectionID, Vector<uint8_t>&&) = 0;
     47        virtual void didClose(RemoteInspectorSocketEndpoint&, ConnectionID) = 0;
    4848    };
    4949
    5050    class Listener {
    5151    public:
    52         virtual bool didAccept(ConnectionID acceptedID, ConnectionID listenerID, Socket::Domain) = 0;
    53         virtual void didClose(ConnectionID) = 0;
     52        virtual ~Listener() { }
     53        virtual Optional<ConnectionID> doAccept(RemoteInspectorSocketEndpoint&, PlatformSocketType) = 0;
     54        virtual void didClose(RemoteInspectorSocketEndpoint&, ConnectionID) = 0;
    5455    };
    5556
    … …  
    6061
    6162    Optional<ConnectionID> connectInet(const char* serverAddr, uint16_t serverPort, Client&);
    62     Optional<ConnectionID> listenInet(const char* address, uint16_t port, Listener&, Client&);
     63    Optional<ConnectionID> listenInet(const char* address, uint16_t port, Listener&);
    6364    void invalidateClient(Client&);
    6465    void invalidateListener(Listener&);
    6566
    6667    void send(ConnectionID, const uint8_t* data, size_t);
     68    inline void send(ConnectionID id, const Vector<uint8_t>& data) { send(id, data.data(), data.size()); }
     69    inline void send(ConnectionID id, const char* data, size_t length) { send(id, reinterpret_cast<const uint8_t*>(data), length); }
    6770
    6871    Optional<ConnectionID> createClient(PlatformSocketType, Client&);
    … …  
    7174    Optional<uint16_t> getPort(ConnectionID) const;
    7275
     76    void disconnect(ConnectionID);
     77
    7378protected:
    74     struct Connection {
     79    struct BaseConnection {
    7580        WTF_MAKE_STRUCT_FAST_ALLOCATED;
    76         explicit Connection(Client& client)
    77             : client(client)
     81
     82        BaseConnection(ConnectionID id, PlatformSocketType socket)
     83            : id { id }
     84            , socket { socket }
     85            , poll { Socket::preparePolling(socket) }
     86        {
     87            ASSERT(Socket::isValid(socket));
     88        }
     89
     90        ConnectionID id;
     91        PlatformSocketType socket;
     92        PollingDescriptor poll;
     93    };
     94
     95    struct ClientConnection : public BaseConnection {
     96        ClientConnection(ConnectionID id, PlatformSocketType socket, Client& client)
     97            : BaseConnection(id, socket)
     98            , client { client }
    7899        {
    79100        }
    80101
    81         ConnectionID id;
     102        Client& client;
    82103        Vector<uint8_t> sendBuffer;
    83         PlatformSocketType socket { INVALID_SOCKET_VALUE };
    84         PollingDescriptor poll;
    85         Client& client;
    86         Listener* listener { };
     104    };
     105
     106    struct ListenerConnection : public BaseConnection {
     107        ListenerConnection(ConnectionID id, PlatformSocketType socket, Listener& listener)
     108            : BaseConnection(id, socket)
     109            , listener { listener }
     110        {
     111        }
     112
     113        Listener& listener;
    87114    };
    88115
    89116    ConnectionID generateConnectionID();
    90     std::unique_ptr<Connection> makeConnection(PlatformSocketType, Client&);
     117    Optional<ConnectionID> createListener(PlatformSocketType, Listener&);
    91118
    92119    void recvIfEnabled(ConnectionID);
    … …  
    98125
    99126    mutable Lock m_connectionsLock;
    100     HashMap<ConnectionID, std::unique_ptr<Connection>> m_connections;
    101     HashMap<ConnectionID, std::unique_ptr<Connection>> m_listeners;
     127    HashMap<ConnectionID, std::unique_ptr<ClientConnection>> m_clients;
     128    HashMap<ConnectionID, std::unique_ptr<ListenerConnection>> m_listeners;
    102129
    103130    PlatformSocketType m_wakeupSendSocket { INVALID_SOCKET_VALUE };

  • trunk/Source/WebKit/ChangeLog

    r267366 r267370  
     12020-09-21  Basuke Suzuki  <basuke.suzuki@sony.com>
     2
     3        [WinCairo][PlayStation] Support different instances of listener client.
     4        https://bugs.webkit.org/show_bug.cgi?id=216733
     5
     6        Reviewed by Don Olmstead.
     7
     8        Follows the change of RemoteInspectorSocketEndpoint::Client interface change.
     9
     10        No new tests because there's no behaivior change.
     11
     12        * UIProcess/Inspector/socket/RemoteInspectorClient.cpp:
     13        (WebKit::RemoteInspectorClient::didClose):
     14        * UIProcess/Inspector/socket/RemoteInspectorClient.h:
     15
    1162020-09-21  Youenn Fablet  <youenn@apple.com>
    217

  • trunk/Source/WebKit/UIProcess/Inspector/socket/RemoteInspectorClient.cpp

    r266885 r267370  
    146146}
    147147
    148 void RemoteInspectorClient::didClose(ConnectionID)
     148void RemoteInspectorClient::didClose(Inspector::RemoteInspectorSocketEndpoint&, ConnectionID)
    149149{
    150150    callOnMainThread([this] {

  • trunk/Source/WebKit/UIProcess/Inspector/socket/RemoteInspectorClient.h

    r255214 r267370  
    8383    void setBackendCommands(const Event&);
    8484
    85     void didClose(ConnectionID) final;
     85    void didClose(Inspector::RemoteInspectorSocketEndpoint&, ConnectionID) final;
    8686    HashMap<String, CallHandler>& dispatchMap() final;
    8787
Note: See TracChangeset for help on using the changeset viewer.