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

Changeset 244657 in webkit


Ignore:
Timestamp:
Apr 25, 2019, 11:54:17 AM (7 years ago)
Author:
Basuke Suzuki
Message:

[RemoteInspector] Fix connection and target identifier types.
​https://bugs.webkit.org/show_bug.cgi?id=197243

Reviewed by Ross Kirsling.

Give dedicated type for RemoteControllableTarget's identifier as Inspector::TargetID.

Also rename ClientID type used in Socket backend to ConnectionID because this is the identifier
socket endpoint assign to the newly created connection. The size was changed to uint32_t.
Enough size for managing connections.

  • inspector/remote/RemoteConnectionToTarget.cpp:

(Inspector::RemoteConnectionToTarget::setup):
(Inspector::RemoteConnectionToTarget::close):
(Inspector::RemoteConnectionToTarget::targetIdentifier const):

  • inspector/remote/RemoteConnectionToTarget.h:
  • inspector/remote/RemoteControllableTarget.h:
  • inspector/remote/RemoteInspector.cpp:

(Inspector::RemoteInspector::nextAvailableTargetIdentifier):
(Inspector::RemoteInspector::registerTarget):
(Inspector::RemoteInspector::unregisterTarget):
(Inspector::RemoteInspector::updateTarget):
(Inspector::RemoteInspector::setupFailed):
(Inspector::RemoteInspector::setupCompleted):
(Inspector::RemoteInspector::waitingForAutomaticInspection):
(Inspector::RemoteInspector::updateTargetListing):

  • inspector/remote/RemoteInspector.h:
  • inspector/remote/cocoa/RemoteConnectionToTargetCocoa.mm:

(Inspector::RemoteConnectionToTarget::targetIdentifier const):
(Inspector::RemoteConnectionToTarget::setup):
(Inspector::RemoteConnectionToTarget::close):

  • inspector/remote/cocoa/RemoteInspectorCocoa.mm:

(Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
(Inspector::RemoteInspector::sendMessageToRemote):
(Inspector::RemoteInspector::receivedSetupMessage):
(Inspector::RemoteInspector::receivedDataMessage):
(Inspector::RemoteInspector::receivedDidCloseMessage):
(Inspector::RemoteInspector::receivedIndicateMessage):
(Inspector::RemoteInspector::receivedAutomaticInspectionRejectMessage):

  • inspector/remote/glib/RemoteInspectorGlib.cpp:

(Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
(Inspector::RemoteInspector::sendMessageToRemote):
(Inspector::RemoteInspector::receivedSetupMessage):
(Inspector::RemoteInspector::receivedDataMessage):
(Inspector::RemoteInspector::receivedCloseMessage):
(Inspector::RemoteInspector::setup):
(Inspector::RemoteInspector::sendMessageToTarget):

  • inspector/remote/socket/RemoteInspectorConnectionClient.cpp:

(Inspector::RemoteInspectorConnectionClient::didReceiveWebInspectorEvent):

  • inspector/remote/socket/RemoteInspectorConnectionClient.h:

(Inspector::RemoteInspectorConnectionClient::didAccept):

  • inspector/remote/socket/RemoteInspectorMessageParser.cpp:

(Inspector::MessageParser::MessageParser):
(Inspector::MessageParser::parse):

  • inspector/remote/socket/RemoteInspectorMessageParser.h:

(Inspector::MessageParser::setDidParseMessageListener):

  • inspector/remote/socket/RemoteInspectorServer.cpp:

(Inspector::RemoteInspectorServer::didAccept):
(Inspector::RemoteInspectorServer::didClose):
(Inspector::RemoteInspectorServer::dispatchMap):
(Inspector::RemoteInspectorServer::sendWebInspectorEvent):
(Inspector::RemoteInspectorServer::sendCloseEvent):
(Inspector::RemoteInspectorServer::connectionClosed):

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

(Inspector::RemoteInspector::didClose):
(Inspector::RemoteInspector::sendMessageToRemote):
(Inspector::RemoteInspector::setup):
(Inspector::RemoteInspector::sendMessageToTarget):

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

(Inspector::RemoteInspectorSocketEndpoint::connectInet):
(Inspector::RemoteInspectorSocketEndpoint::isListening):
(Inspector::RemoteInspectorSocketEndpoint::workerThread):
(Inspector::RemoteInspectorSocketEndpoint::createClient):
(Inspector::RemoteInspectorSocketEndpoint::recvIfEnabled):
(Inspector::RemoteInspectorSocketEndpoint::sendIfEnabled):
(Inspector::RemoteInspectorSocketEndpoint::send):
(Inspector::RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled):

  • inspector/remote/socket/RemoteInspectorSocketEndpoint.h:
Location:
trunk/Source/JavaScriptCore
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r244653 r244657  
     12019-04-25  Basuke Suzuki  <Basuke.Suzuki@sony.com>
     2
     3        [RemoteInspector] Fix connection and target identifier types.
     4        https://bugs.webkit.org/show_bug.cgi?id=197243
     5
     6        Reviewed by Ross Kirsling.
     7
     8        Give dedicated type for RemoteControllableTarget's identifier as Inspector::TargetID.
     9
     10        Also rename ClientID type used in Socket backend to ConnectionID because this is the identifier
     11        socket endpoint assign to the newly created connection. The size was changed to uint32_t.
     12        Enough size for managing connections.
     13
     14        * inspector/remote/RemoteConnectionToTarget.cpp:
     15        (Inspector::RemoteConnectionToTarget::setup):
     16        (Inspector::RemoteConnectionToTarget::close):
     17        (Inspector::RemoteConnectionToTarget::targetIdentifier const):
     18        * inspector/remote/RemoteConnectionToTarget.h:
     19        * inspector/remote/RemoteControllableTarget.h:
     20        * inspector/remote/RemoteInspector.cpp:
     21        (Inspector::RemoteInspector::nextAvailableTargetIdentifier):
     22        (Inspector::RemoteInspector::registerTarget):
     23        (Inspector::RemoteInspector::unregisterTarget):
     24        (Inspector::RemoteInspector::updateTarget):
     25        (Inspector::RemoteInspector::setupFailed):
     26        (Inspector::RemoteInspector::setupCompleted):
     27        (Inspector::RemoteInspector::waitingForAutomaticInspection):
     28        (Inspector::RemoteInspector::updateTargetListing):
     29        * inspector/remote/RemoteInspector.h:
     30        * inspector/remote/cocoa/RemoteConnectionToTargetCocoa.mm:
     31        (Inspector::RemoteConnectionToTarget::targetIdentifier const):
     32        (Inspector::RemoteConnectionToTarget::setup):
     33        (Inspector::RemoteConnectionToTarget::close):
     34        * inspector/remote/cocoa/RemoteInspectorCocoa.mm:
     35        (Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
     36        (Inspector::RemoteInspector::sendMessageToRemote):
     37        (Inspector::RemoteInspector::receivedSetupMessage):
     38        (Inspector::RemoteInspector::receivedDataMessage):
     39        (Inspector::RemoteInspector::receivedDidCloseMessage):
     40        (Inspector::RemoteInspector::receivedIndicateMessage):
     41        (Inspector::RemoteInspector::receivedAutomaticInspectionRejectMessage):
     42        * inspector/remote/glib/RemoteInspectorGlib.cpp:
     43        (Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
     44        (Inspector::RemoteInspector::sendMessageToRemote):
     45        (Inspector::RemoteInspector::receivedSetupMessage):
     46        (Inspector::RemoteInspector::receivedDataMessage):
     47        (Inspector::RemoteInspector::receivedCloseMessage):
     48        (Inspector::RemoteInspector::setup):
     49        (Inspector::RemoteInspector::sendMessageToTarget):
     50        * inspector/remote/socket/RemoteInspectorConnectionClient.cpp:
     51        (Inspector::RemoteInspectorConnectionClient::didReceiveWebInspectorEvent):
     52        * inspector/remote/socket/RemoteInspectorConnectionClient.h:
     53        (Inspector::RemoteInspectorConnectionClient::didAccept):
     54        * inspector/remote/socket/RemoteInspectorMessageParser.cpp:
     55        (Inspector::MessageParser::MessageParser):
     56        (Inspector::MessageParser::parse):
     57        * inspector/remote/socket/RemoteInspectorMessageParser.h:
     58        (Inspector::MessageParser::setDidParseMessageListener):
     59        * inspector/remote/socket/RemoteInspectorServer.cpp:
     60        (Inspector::RemoteInspectorServer::didAccept):
     61        (Inspector::RemoteInspectorServer::didClose):
     62        (Inspector::RemoteInspectorServer::dispatchMap):
     63        (Inspector::RemoteInspectorServer::sendWebInspectorEvent):
     64        (Inspector::RemoteInspectorServer::sendCloseEvent):
     65        (Inspector::RemoteInspectorServer::connectionClosed):
     66        * inspector/remote/socket/RemoteInspectorServer.h:
     67        * inspector/remote/socket/RemoteInspectorSocket.cpp:
     68        (Inspector::RemoteInspector::didClose):
     69        (Inspector::RemoteInspector::sendMessageToRemote):
     70        (Inspector::RemoteInspector::setup):
     71        (Inspector::RemoteInspector::sendMessageToTarget):
     72        * inspector/remote/socket/RemoteInspectorSocket.h:
     73        * inspector/remote/socket/RemoteInspectorSocketEndpoint.cpp:
     74        (Inspector::RemoteInspectorSocketEndpoint::connectInet):
     75        (Inspector::RemoteInspectorSocketEndpoint::isListening):
     76        (Inspector::RemoteInspectorSocketEndpoint::workerThread):
     77        (Inspector::RemoteInspectorSocketEndpoint::createClient):
     78        (Inspector::RemoteInspectorSocketEndpoint::recvIfEnabled):
     79        (Inspector::RemoteInspectorSocketEndpoint::sendIfEnabled):
     80        (Inspector::RemoteInspectorSocketEndpoint::send):
     81        (Inspector::RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled):
     82        * inspector/remote/socket/RemoteInspectorSocketEndpoint.h:
     83
    1842019-04-25  Alex Christensen  <achristensen@webkit.org>
    285

  • trunk/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.cpp

    r242576 r244657  
    5050        return false;
    5151
    52     unsigned targetIdentifier = this->targetIdentifier().valueOr(0);
     52    auto targetIdentifier = this->targetIdentifier().valueOr(0);
    5353
    5454    if (!m_target || !m_target->remoteControlAllowed()) {
    … …  
    9191        return;
    9292
    93     unsigned targetIdentifier = m_target->targetIdentifier();
     93    auto targetIdentifier = m_target->targetIdentifier();
    9494
    9595    if (m_connected)
    … …  
    107107}
    108108
    109 Optional<unsigned> RemoteConnectionToTarget::targetIdentifier() const
     109Optional<TargetID> RemoteConnectionToTarget::targetIdentifier() const
    110110{
    111     return m_target ? Optional<unsigned>(m_target->targetIdentifier()) : WTF::nullopt;
     111    return m_target ? Optional<TargetID>(m_target->targetIdentifier()) : WTF::nullopt;
    112112}
    113113

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

    r239427 r244657  
    2929
    3030#include "InspectorFrontendChannel.h"
     31#include "RemoteControllableTarget.h"
    3132#include <wtf/Lock.h>
    3233#include <wtf/ThreadSafeRefCounted.h>
    … …  
    6667    void targetClosed();
    6768
    68     Optional<unsigned> targetIdentifier() const;
     69    Optional<TargetID> targetIdentifier() const;
    6970#if PLATFORM(COCOA)
    7071    NSString *connectionIdentifier() const;

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

    r238206 r244657  
    3939class FrontendChannel;
    4040
     41using TargetID = unsigned;
     42
    4143class JS_EXPORT_PRIVATE RemoteControllableTarget {
    4244public:
    … …  
    4951    virtual void disconnect(FrontendChannel&) = 0;
    5052
    51     unsigned targetIdentifier() const { return m_identifier; }
    52     void setTargetIdentifier(unsigned identifier) { m_identifier = identifier; }
     53    TargetID targetIdentifier() const { return m_identifier; }
     54    void setTargetIdentifier(TargetID identifier) { m_identifier = identifier; }
    5355
    5456    enum class Type { JavaScript, ServiceWorker, Web, Automation };
    … …  
    6365
    6466private:
    65     unsigned m_identifier { 0 };
     67    TargetID m_identifier { 0 };
    6668};
    6769

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

    r242576 r244657  
    4545}
    4646
    47 unsigned RemoteInspector::nextAvailableTargetIdentifier()
    48 {
    49     unsigned nextValidTargetIdentifier;
     47TargetID RemoteInspector::nextAvailableTargetIdentifier()
     48{
     49    TargetID nextValidTargetIdentifier;
    5050    do {
    5151        nextValidTargetIdentifier = m_nextAvailableTargetIdentifier++;
    52     } while (!nextValidTargetIdentifier || nextValidTargetIdentifier == std::numeric_limits<unsigned>::max() || m_targetMap.contains(nextValidTargetIdentifier));
     52    } while (!nextValidTargetIdentifier || nextValidTargetIdentifier == std::numeric_limits<TargetID>::max() || m_targetMap.contains(nextValidTargetIdentifier));
    5353    return nextValidTargetIdentifier;
    5454}
    … …  
    6060    LockHolder lock(m_mutex);
    6161
    62     unsigned targetIdentifier = nextAvailableTargetIdentifier();
     62    auto targetIdentifier = nextAvailableTargetIdentifier();
    6363    target->setTargetIdentifier(targetIdentifier);
    6464
    … …  
    8383    LockHolder lock(m_mutex);
    8484
    85     unsigned targetIdentifier = target->targetIdentifier();
     85    auto targetIdentifier = target->targetIdentifier();
    8686    if (!targetIdentifier)
    8787        return;
    … …  
    105105    LockHolder lock(m_mutex);
    106106
    107     unsigned targetIdentifier = target->targetIdentifier();
     107    auto targetIdentifier = target->targetIdentifier();
    108108    if (!targetIdentifier)
    109109        return;
    … …  
    157157}
    158158
    159 void RemoteInspector::setupFailed(unsigned targetIdentifier)
     159void RemoteInspector::setupFailed(TargetID targetIdentifier)
    160160{
    161161    LockHolder lock(m_mutex);
    … …  
    171171}
    172172
    173 void RemoteInspector::setupCompleted(unsigned targetIdentifier)
     173void RemoteInspector::setupCompleted(TargetID targetIdentifier)
    174174{
    175175    LockHolder lock(m_mutex);
    … …  
    179179}
    180180
    181 bool RemoteInspector::waitingForAutomaticInspection(unsigned)
     181bool RemoteInspector::waitingForAutomaticInspection(TargetID)
    182182{
    183183    // We don't take the lock to check this because we assume it will be checked repeatedly.
    … …  
    209209}
    210210
    211 void RemoteInspector::updateTargetListing(unsigned targetIdentifier)
     211void RemoteInspector::updateTargetListing(TargetID targetIdentifier)
    212212{
    213213    auto target = m_targetMap.get(targetIdentifier);

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

    r244501 r244657  
    2828#if ENABLE(REMOTE_INSPECTOR)
    2929
     30#include "RemoteControllableTarget.h"
     31
    3032#include <utility>
    3133#include <wtf/Forward.h>
    … …  
    114116    void unregisterTarget(RemoteControllableTarget*);
    115117    void updateTarget(RemoteControllableTarget*);
    116     void sendMessageToRemote(unsigned targetIdentifier, const String& message);
     118    void sendMessageToRemote(TargetID, const String& message);
    117119
    118120    RemoteInspector::Client* client() const { return m_client; }
    … …  
    121123    Optional<RemoteInspector::Client::Capabilities> clientCapabilities() const { return m_clientCapabilities; }
    122124
    123     void setupFailed(unsigned targetIdentifier);
    124     void setupCompleted(unsigned targetIdentifier);
    125     bool waitingForAutomaticInspection(unsigned targetIdentifier);
     125    void setupFailed(TargetID);
     126    void setupCompleted(TargetID);
     127    bool waitingForAutomaticInspection(TargetID);
    126128    void updateAutomaticInspectionCandidate(RemoteInspectionTarget*);
    127129
    … …  
    140142#endif
    141143
    142     void updateTargetListing(unsigned targetIdentifier);
     144    void updateTargetListing(TargetID);
    143145
    144146#if USE(GLIB)
    … …  
    146148#endif
    147149#if USE(GLIB) || PLATFORM(PLAYSTATION)
    148     void setup(unsigned targetIdentifier);
    149     void sendMessageToTarget(unsigned targetIdentifier, const char* message);
     150    void setup(TargetID);
     151    void sendMessageToTarget(TargetID, const char* message);
    150152#endif
    151153#if PLATFORM(PLAYSTATION)
    … …  
    156158    RemoteInspector();
    157159
    158     unsigned nextAvailableTargetIdentifier();
     160    TargetID nextAvailableTargetIdentifier();
    159161
    160162    enum class StopSource { API, XPCMessage };
    … …  
    169171
    170172    void receivedGetTargetListMessage();
    171     void receivedSetupMessage(unsigned targetIdentifier);
    172     void receivedDataMessage(unsigned targetIdentifier, const char* message);
    173     void receivedCloseMessage(unsigned targetIdentifier);
     173    void receivedSetupMessage(TargetID);
     174    void receivedDataMessage(TargetID, const char* message);
     175    void receivedCloseMessage(TargetID);
    174176    void receivedAutomationSessionRequestMessage(const char* sessionID);
    175177#endif
    … …  
    207209#if PLATFORM(PLAYSTATION)
    208210    HashMap<String, CallHandler>& dispatchMap() override;
    209     void didClose(ClientID) override;
     211    void didClose(ConnectionID) override;
    210212
    211213    void sendWebInspectorEvent(const String&);
    212214
    213     void receivedGetTargetListMessage(const struct Event&);
    214     void receivedSetupMessage(const struct Event&);
    215     void receivedDataMessage(const struct Event&);
    216     void receivedCloseMessage(const struct Event&);
     215    void receivedGetTargetListMessage(const Event&);
     216    void receivedSetupMessage(const Event&);
     217    void receivedDataMessage(const Event&);
     218    void receivedCloseMessage(const Event&);
    217219#endif
    218220    static bool startEnabled;
    … …  
    224226    Lock m_mutex;
    225227
    226     HashMap<unsigned, RemoteControllableTarget*> m_targetMap;
    227     HashMap<unsigned, RefPtr<RemoteConnectionToTarget>> m_targetConnectionMap;
    228     HashMap<unsigned, TargetListing> m_targetListingMap;
     228    HashMap<TargetID, RemoteControllableTarget*> m_targetMap;
     229    HashMap<TargetID, RefPtr<RemoteConnectionToTarget>> m_targetConnectionMap;
     230    HashMap<TargetID, TargetListing> m_targetListingMap;
    229231
    230232#if PLATFORM(COCOA)
    … …  
    239241    std::unique_ptr<RemoteInspectorSocketEndpoint> m_socketConnection;
    240242    static PlatformSocketType s_connectionIdentifier;
    241     Optional<ClientID> m_clientID;
     243    Optional<ConnectionID> m_clientID;
    242244#endif
    243245
    … …  
    248250    dispatch_queue_t m_xpcQueue;
    249251#endif
    250     unsigned m_nextAvailableTargetIdentifier { 1 };
     252    TargetID m_nextAvailableTargetIdentifier { 1 };
    251253    int m_notifyToken { 0 };
    252254    bool m_enabled { false };
    … …  
    261263    bool m_automaticInspectionEnabled { false };
    262264    bool m_automaticInspectionPaused { false };
    263     unsigned m_automaticInspectionCandidateTargetIdentifier { 0 };
     265    TargetID m_automaticInspectionCandidateTargetIdentifier { 0 };
    264266};
    265267

  • trunk/Source/JavaScriptCore/inspector/remote/cocoa/RemoteConnectionToTargetCocoa.mm

    r242576 r244657  
    121121}
    122122
    123 Optional<unsigned> RemoteConnectionToTarget::targetIdentifier() const
    124 {
    125     return m_target ? Optional<unsigned>(m_target->targetIdentifier()) : WTF::nullopt;
     123Optional<TargetID> RemoteConnectionToTarget::targetIdentifier() const
     124{
     125    return m_target ? Optional<TargetID>(m_target->targetIdentifier()) : WTF::nullopt;
    126126}
    127127
    … …  
    160160        return false;
    161161
    162     unsigned targetIdentifier = this->targetIdentifier().valueOr(0);
     162    auto targetIdentifier = this->targetIdentifier().valueOr(0);
    163163   
    164164    ref();
    … …  
    199199void RemoteConnectionToTarget::close()
    200200{
    201     unsigned targetIdentifier = m_target ? m_target->targetIdentifier() : 0;
     201    auto targetIdentifier = m_target ? m_target->targetIdentifier() : 0;
    202202   
    203203    ref();

  • trunk/Source/JavaScriptCore/inspector/remote/cocoa/RemoteInspectorCocoa.mm

    r243795 r244657  
    123123        LockHolder lock(m_mutex);
    124124
    125         unsigned targetIdentifier = target->targetIdentifier();
     125        auto targetIdentifier = target->targetIdentifier();
    126126        if (!targetIdentifier)
    127127            return;
    … …  
    198198}
    199199
    200 void RemoteInspector::sendMessageToRemote(unsigned targetIdentifier, const String& message)
     200void RemoteInspector::sendMessageToRemote(TargetID targetIdentifier, const String& message)
    201201{
    202202    LockHolder lock(m_mutex);
    … …  
    495495    BOOL automaticallyPause = automaticallyPauseNumber.boolValue;
    496496
    497     unsigned targetIdentifier = targetIdentifierNumber.unsignedIntValue;
     497    TargetID targetIdentifier = targetIdentifierNumber.unsignedIntValue;
    498498    if (!targetIdentifier)
    499499        return;
    … …  
    538538    BAIL_IF_UNEXPECTED_TYPE(data, [NSData class]);
    539539
    540     unsigned targetIdentifier = targetIdentifierNumber.unsignedIntValue;
     540    TargetID targetIdentifier = targetIdentifierNumber.unsignedIntValue;
    541541    if (!targetIdentifier)
    542542        return;
    … …  
    558558    BAIL_IF_UNEXPECTED_TYPE(connectionIdentifier, [NSString class]);
    559559
    560     unsigned targetIdentifier = targetIdentifierNumber.unsignedIntValue;
     560    TargetID targetIdentifier = targetIdentifierNumber.unsignedIntValue;
    561561    if (!targetIdentifier)
    562562        return;
    … …  
    589589    BOOL indicateEnabled = indicateEnabledNumber.boolValue;
    590590
    591     unsigned targetIdentifier = targetIdentifierNumber.unsignedIntValue;
     591    TargetID targetIdentifier = targetIdentifierNumber.unsignedIntValue;
    592592    if (!targetIdentifier)
    593593        return;
    … …  
    673673    BAIL_IF_UNEXPECTED_TYPE(targetIdentifierNumber, [NSNumber class]);
    674674
    675     unsigned targetIdentifier = targetIdentifierNumber.unsignedIntValue;
     675    TargetID targetIdentifier = targetIdentifierNumber.unsignedIntValue;
    676676    if (!targetIdentifier)
    677677        return;

  • trunk/Source/JavaScriptCore/inspector/remote/glib/RemoteInspectorGlib.cpp

    r242576 r244657  
    246246
    247247    ASSERT(target);
    248     unsigned targetIdentifier = target->targetIdentifier();
     248    auto targetIdentifier = target->targetIdentifier();
    249249    if (!targetIdentifier)
    250250        return;
    … …  
    273273}
    274274
    275 void RemoteInspector::sendMessageToRemote(unsigned targetIdentifier, const String& message)
     275void RemoteInspector::sendMessageToRemote(TargetID targetIdentifier, const String& message)
    276276{
    277277    LockHolder lock(m_mutex);
    … …  
    292292}
    293293
    294 void RemoteInspector::receivedSetupMessage(unsigned targetIdentifier)
     294void RemoteInspector::receivedSetupMessage(TargetID targetIdentifier)
    295295{
    296296    setup(targetIdentifier);
    297297}
    298298
    299 void RemoteInspector::receivedDataMessage(unsigned targetIdentifier, const char* message)
     299void RemoteInspector::receivedDataMessage(TargetID targetIdentifier, const char* message)
    300300{
    301301    RefPtr<RemoteConnectionToTarget> connectionToTarget;
    … …  
    309309}
    310310
    311 void RemoteInspector::receivedCloseMessage(unsigned targetIdentifier)
     311void RemoteInspector::receivedCloseMessage(TargetID targetIdentifier)
    312312{
    313313    RefPtr<RemoteConnectionToTarget> connectionToTarget;
    … …  
    326326}
    327327
    328 void RemoteInspector::setup(unsigned targetIdentifier)
     328void RemoteInspector::setup(TargetID targetIdentifier)
    329329{
    330330    RemoteControllableTarget* target;
    … …  
    349349}
    350350
    351 void RemoteInspector::sendMessageToTarget(unsigned targetIdentifier, const char* message)
     351void RemoteInspector::sendMessageToTarget(TargetID targetIdentifier, const char* message)
    352352{
    353353    if (auto connectionToTarget = m_targetConnectionMap.get(targetIdentifier))

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

    r244501 r244657  
    3535namespace Inspector {
    3636
    37 void RemoteInspectorConnectionClient::didReceiveWebInspectorEvent(ClientID clientID, Vector<uint8_t>&& data)
     37void RemoteInspectorConnectionClient::didReceiveWebInspectorEvent(ConnectionID clientID, Vector<uint8_t>&& data)
    3838{
    3939    ASSERT(!isMainThread());
    … …  
    5656        return;
    5757
    58     struct Event event;
     58    Event event;
    5959    event.clientID = clientID;
    6060
    61     uint64_t connectionID;
     61    ConnectionID connectionID;
    6262    if (messageObject->getInteger("connectionID"_s, connectionID))
    6363        event.connectionID = connectionID;
    6464
    65     uint64_t targetID;
     65    TargetID targetID;
    6666    if (messageObject->getInteger("targetID"_s, targetID))
    6767        event.targetID = targetID;

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

    r244501 r244657  
    3636class RemoteInspectorConnectionClient : public CanMakeWeakPtr<RemoteInspectorConnectionClient> {
    3737public:
    38     void didReceiveWebInspectorEvent(ClientID, Vector<uint8_t>&&);
    39     virtual void didAccept(ClientID, Socket::Domain) { };
    40     virtual void didClose(ClientID) = 0;
     38    void didReceiveWebInspectorEvent(ConnectionID, Vector<uint8_t>&&);
     39    virtual void didAccept(ConnectionID, Socket::Domain) { };
     40    virtual void didClose(ConnectionID) = 0;
    4141
    4242    struct Event {
    43         ClientID clientID;
    44         Optional<uint64_t> connectionID;
    45         Optional<uint64_t> targetID;
     43        ConnectionID clientID { };
     44        Optional<ConnectionID> connectionID;
     45        Optional<TargetID> targetID;
    4646        Optional<String> message;
    4747    };
    4848
    49     using CallHandler = void (RemoteInspectorConnectionClient::*)(const struct Event&);
     49    using CallHandler = void (RemoteInspectorConnectionClient::*)(const Event&);
    5050    virtual HashMap<String, CallHandler>& dispatchMap() = 0;
    5151};

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

    r244501 r244657  
    4242*/
    4343
    44 MessageParser::MessageParser(ClientID clientID, size_t bufferSize)
    45     : m_clientID(clientID)
     44MessageParser::MessageParser(ConnectionID id, size_t bufferSize)
     45    : m_connectionID(id)
    4646{
    4747    m_buffer.reserveCapacity(bufferSize);
    … …  
    105105
    106106        if (m_didParseMessageListener)
    107             m_didParseMessageListener(m_clientID, WTFMove(dataBuffer));
     107            m_didParseMessageListener(m_connectionID, WTFMove(dataBuffer));
    108108
    109109        m_buffer.remove(0, messageSize);

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

    r244501 r244657  
    3737    static Vector<uint8_t> createMessage(const uint8_t*, size_t);
    3838
    39     MessageParser(ClientID, size_t);
     39    MessageParser(ConnectionID, size_t);
    4040    void pushReceivedData(const uint8_t*, size_t);
    41     void setDidParseMessageListener(Function<void(ClientID, Vector<uint8_t>)>&& listener) { m_didParseMessageListener = WTFMove(listener); }
     41    void setDidParseMessageListener(Function<void(ConnectionID, Vector<uint8_t>)>&& listener) { m_didParseMessageListener = WTFMove(listener); }
    4242
    4343    void clearReceivedData();
    … …  
    4646    bool parse();
    4747
    48     Function<void(ClientID, Vector<uint8_t>&&)> m_didParseMessageListener;
     48    Function<void(ConnectionID, Vector<uint8_t>&&)> m_didParseMessageListener;
    4949    Vector<uint8_t> m_buffer;
    50     ClientID m_clientID;
     50    ConnectionID m_connectionID;
    5151};
    5252

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

    r244501 r244657  
    4545}
    4646
    47 void RemoteInspectorServer::didAccept(ClientID clientID, Socket::Domain type)
     47void RemoteInspectorServer::didAccept(ConnectionID id, Socket::Domain type)
    4848{
    4949    ASSERT(!isMainThread());
    … …  
    5454            return;
    5555        }
    56         m_clientConnection = clientID;
     56        m_clientConnection = id;
    5757    } else if (type == Socket::Domain::Local) {
    5858        LockHolder lock(m_connectionsLock);
    59         m_inspectorConnections.append(clientID);
    60     }
    61 }
    62 
    63 void RemoteInspectorServer::didClose(ClientID clientID)
     59        m_inspectorConnections.append(id);
     60    }
     61}
     62
     63void RemoteInspectorServer::didClose(ConnectionID id)
    6464{
    6565    ASSERT(!isMainThread());
    6666
    67     if (clientID == m_clientConnection) {
     67    if (id == m_clientConnection) {
    6868        // Connection from the remote client closed.
    6969        callOnMainThread([this] {
    … …  
    7474
    7575    // Connection from WebProcess closed.
    76     callOnMainThread([this, clientID] {
    77         connectionClosed(clientID);
     76    callOnMainThread([this, id] {
     77        connectionClosed(id);
    7878    });
    7979}
    … …  
    8282{
    8383    static NeverDestroyed<HashMap<String, CallHandler>> dispatchMap = HashMap<String, CallHandler>({
    84         {"SetTargetList"_s, static_cast<CallHandler>(&RemoteInspectorServer::setTargetList)},
    85         {"SetupInspectorClient"_s, static_cast<CallHandler>(&RemoteInspectorServer::setupInspectorClient)},
    86         {"Setup"_s, static_cast<CallHandler>(&RemoteInspectorServer::setup)},
    87         {"FrontendDidClose"_s, static_cast<CallHandler>(&RemoteInspectorServer::close)},
    88         {"SendMessageToFrontend"_s, static_cast<CallHandler>(&RemoteInspectorServer::sendMessageToFrontend)},
    89         {"SendMessageToBackend"_s, static_cast<CallHandler>(&RemoteInspectorServer::sendMessageToBackend)},
     84        {"SetTargetList"_s, &RemoteInspectorServer::setTargetList},
     85        {"SetupInspectorClient"_s, &RemoteInspectorServer::setupInspectorClient},
     86        {"Setup"_s, &RemoteInspectorServer::setup},
     87        {"FrontendDidClose"_s, &RemoteInspectorServer::close},
     88        {"SendMessageToFrontend"_s, &RemoteInspectorServer::sendMessageToFrontend},
     89        {"SendMessageToBackend"_s, &RemoteInspectorServer::sendMessageToBackend},
    9090    });
    9191
    … …  
    9393}
    9494
    95 void RemoteInspectorServer::sendWebInspectorEvent(ClientID clientID, const String& event)
     95void RemoteInspectorServer::sendWebInspectorEvent(ConnectionID id, const String& event)
    9696{
    9797    const CString message = event.utf8();
    98     m_server->send(clientID, reinterpret_cast<const uint8_t*>(message.data()), message.length());
     98    m_server->send(id, reinterpret_cast<const uint8_t*>(message.data()), message.length());
    9999}
    100100
    … …  
    158158}
    159159
    160 void RemoteInspectorServer::sendCloseEvent(uint64_t connectionID, uint64_t targetID)
     160void RemoteInspectorServer::sendCloseEvent(ConnectionID connectionID, TargetID targetID)
    161161{
    162162    ASSERT(isMainThread());
    … …  
    187187}
    188188
    189 void RemoteInspectorServer::connectionClosed(uint64_t clientID)
     189void RemoteInspectorServer::connectionClosed(ConnectionID clientID)
    190190{
    191191    ASSERT(isMainThread());

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

    r244501 r244657  
    4747
    4848private:
    49     void connectionClosed(uint64_t connectionID);
     49    void connectionClosed(ConnectionID);
    5050
    51     void setTargetList(const struct Event&);
    52     void setupInspectorClient(const struct Event&);
    53     void setup(const struct Event&);
    54     void close(const struct Event&);
    55     void sendMessageToFrontend(const struct Event&);
    56     void sendMessageToBackend(const struct Event&);
     51    void setTargetList(const Event&);
     52    void setupInspectorClient(const Event&);
     53    void setup(const Event&);
     54    void close(const Event&);
     55    void sendMessageToFrontend(const Event&);
     56    void sendMessageToBackend(const Event&);
    5757
    58     void sendCloseEvent(uint64_t connectionID, uint64_t targetID);
     58    void sendCloseEvent(ConnectionID, TargetID);
    5959    void clientConnectionClosed();
    6060
    61     void didAccept(ClientID, Socket::Domain) override;
    62     void didClose(ClientID) override;
     61    void didAccept(ConnectionID, Socket::Domain) override;
     62    void didClose(ConnectionID) override;
    6363
    64     void sendWebInspectorEvent(ClientID, const String&);
     64    void sendWebInspectorEvent(ConnectionID, const String&);
    6565
    66     HashMap<String, CallHandler>& dispatchMap();
     66    HashMap<String, CallHandler>& dispatchMap() override;
    6767
    68     HashSet<std::pair<uint64_t, uint64_t>> m_inspectionTargets;
     68    HashSet<std::pair<ConnectionID, TargetID>> m_inspectionTargets;
    6969    std::unique_ptr<RemoteInspectorSocketEndpoint> m_server;
    7070
    7171    // Connections to the WebProcess.
    72     Vector<ClientID> m_inspectorConnections;
     72    Vector<ConnectionID> m_inspectorConnections;
    7373    Lock m_connectionsLock;
    7474
    7575    // Connections from RemoteInspectorClient.
    76     Optional<ClientID> m_clientConnection;
     76    Optional<ConnectionID> m_clientConnection;
    7777};
    7878

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

    r244501 r244657  
    5252}
    5353
    54 void RemoteInspector::didClose(ClientID clientID)
    55 {
    56     if (clientID != m_clientID.value())
     54void RemoteInspector::didClose(ConnectionID id)
     55{
     56    if (id != m_clientID.value())
    5757        return;
    5858
    … …  
    193193}
    194194
    195 void RemoteInspector::sendMessageToRemote(unsigned targetIdentifier, const String& message)
     195void RemoteInspector::sendMessageToRemote(TargetID targetIdentifier, const String& message)
    196196{
    197197    LockHolder lock(m_mutex);
    … …  
    262262}
    263263
    264 void RemoteInspector::setup(unsigned targetIdentifier)
     264void RemoteInspector::setup(TargetID targetIdentifier)
    265265{
    266266    RemoteControllableTarget* target;
    … …  
    285285}
    286286
    287 void RemoteInspector::sendMessageToTarget(unsigned targetIdentifier, const char* message)
     287void RemoteInspector::sendMessageToTarget(TargetID targetIdentifier, const char* message)
    288288{
    289289    if (auto connectionToTarget = m_targetConnectionMap.get(targetIdentifier))

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

    r244501 r244657  
    4242namespace Inspector {
    4343
     44using ConnectionID = uint32_t;
     45
    4446#if OS(WINDOWS)
    4547
    46 using ClientID = unsigned;
    4748using PlatformSocketType = SOCKET;
    4849using PollingDescriptor = WSAPOLLFD;
    … …  
    5152#else
    5253
    53 using ClientID = unsigned;
    5454using PlatformSocketType = int;
    5555using PollingDescriptor = struct pollfd;

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

    r244501 r244657  
    7070}
    7171
    72 Optional<ClientID> RemoteInspectorSocketEndpoint::connectInet(const char* serverAddress, uint16_t serverPort)
     72Optional<ConnectionID> RemoteInspectorSocketEndpoint::connectInet(const char* serverAddress, uint16_t serverPort)
    7373{
    7474    if (auto socket = Socket::connect(serverAddress, serverPort))
    … …  
    8787}
    8888
    89 bool RemoteInspectorSocketEndpoint::isListening(ClientID id)
     89bool RemoteInspectorSocketEndpoint::isListening(ConnectionID id)
    9090{
    9191    LockHolder lock(m_connectionsLock);
    … …  
    101101    while (!m_shouldAbortWorkerThread) {
    102102        Vector<PollingDescriptor> pollfds;
    103         Vector<ClientID> ids;
     103        Vector<ConnectionID> ids;
    104104        {
    105105            LockHolder lock(m_connectionsLock);
    … …  
    133133}
    134134
    135 Optional<ClientID> RemoteInspectorSocketEndpoint::createClient(PlatformSocketType socket)
     135Optional<ConnectionID> RemoteInspectorSocketEndpoint::createClient(PlatformSocketType socket)
    136136{
    137137    if (!Socket::isValid(socket))
    … …  
    140140    LockHolder lock(m_connectionsLock);
    141141
    142     ClientID id;
     142    ConnectionID id;
    143143    do {
    144144        id = cryptographicallyRandomNumber();
    … …  
    152152    connection->socket = socket;
    153153    connection->parser = std::make_unique<MessageParser>(id, Socket::BufferSize);
    154     connection->parser->setDidParseMessageListener([this](ClientID id, Vector<uint8_t>&& data) {
     154    connection->parser->setDidParseMessageListener([this](ConnectionID id, Vector<uint8_t>&& data) {
    155155        if (m_inspectorClient)
    156156            m_inspectorClient->didReceiveWebInspectorEvent(id, WTFMove(data));
    … …  
    162162}
    163163
    164 void RemoteInspectorSocketEndpoint::recvIfEnabled(ClientID clientID)
    165 {
    166     LockHolder lock(m_connectionsLock);
    167     if (const auto& connection = m_connections.get(clientID)) {
     164void RemoteInspectorSocketEndpoint::recvIfEnabled(ConnectionID id)
     165{
     166    LockHolder lock(m_connectionsLock);
     167    if (const auto& connection = m_connections.get(id)) {
    168168        Vector<uint8_t> recvBuffer(Socket::BufferSize);
    169169        if (auto readSize = Socket::read(connection->socket, recvBuffer.data(), recvBuffer.size())) {
    … …  
    174174
    175175        Socket::close(connection->socket);
    176         m_connections.remove(clientID);
     176        m_connections.remove(id);
    177177
    178178        lock.unlockEarly();
    179179        if (m_inspectorClient)
    180             m_inspectorClient->didClose(clientID);
    181     }
    182 }
    183 
    184 void RemoteInspectorSocketEndpoint::sendIfEnabled(ClientID clientID)
    185 {
    186     LockHolder lock(m_connectionsLock);
    187     if (const auto& connection = m_connections.get(clientID)) {
     180            m_inspectorClient->didClose(id);
     181    }
     182}
     183
     184void RemoteInspectorSocketEndpoint::sendIfEnabled(ConnectionID id)
     185{
     186    LockHolder lock(m_connectionsLock);
     187    if (const auto& connection = m_connections.get(id)) {
    188188        Socket::clearWaitingWritable(connection->poll);
    189189
    … …  
    207207}
    208208
    209 void RemoteInspectorSocketEndpoint::send(ClientID clientID, const uint8_t* data, size_t size)
    210 {
    211     LockHolder lock(m_connectionsLock);
    212     if (const auto& connection = m_connections.get(clientID)) {
     209void RemoteInspectorSocketEndpoint::send(ConnectionID id, const uint8_t* data, size_t size)
     210{
     211    LockHolder lock(m_connectionsLock);
     212    if (const auto& connection = m_connections.get(id)) {
    213213        auto message = MessageParser::createMessage(data, size);
    214214        if (message.isEmpty())
    … …  
    235235}
    236236
    237 void RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled(ClientID id)
     237void RemoteInspectorSocketEndpoint::acceptInetSocketIfEnabled(ConnectionID id)
    238238{
    239239    if (!isListening(id))

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

    r244501 r244657  
    5353    ~RemoteInspectorSocketEndpoint();
    5454
    55     Optional<ClientID> connectInet(const char* serverAddr, uint16_t serverPort);
     55    Optional<ConnectionID> connectInet(const char* serverAddr, uint16_t serverPort);
    5656    bool listenInet(uint16_t port);
    5757
    58     void send(ClientID, const uint8_t* data, size_t);
     58    void send(ConnectionID, const uint8_t* data, size_t);
    5959
    60     Optional<ClientID> createClient(PlatformSocketType fd);
     60    Optional<ConnectionID> createClient(PlatformSocketType fd);
    6161
    6262protected:
    63     void recvIfEnabled(ClientID);
    64     void sendIfEnabled(ClientID);
     63    void recvIfEnabled(ConnectionID);
     64    void sendIfEnabled(ConnectionID);
    6565    void workerThread();
    6666    void wakeupWorkerThread();
    67     void acceptInetSocketIfEnabled(ClientID);
    68     bool isListening(ClientID);
     67    void acceptInetSocketIfEnabled(ConnectionID);
     68    bool isListening(ConnectionID);
    6969
    7070    Lock m_connectionsLock;
    71     HashMap<ClientID, std::unique_ptr<Socket::Connection>> m_connections;
     71    HashMap<ConnectionID, std::unique_ptr<Socket::Connection>> m_connections;
    7272
    7373    PlatformSocketType m_wakeupSendSocket { INVALID_SOCKET_VALUE };
Note: See TracChangeset for help on using the changeset viewer.