Changeset 196515 in webkit


Ignore:
Timestamp:
Feb 12, 2016 2:35:45 PM (8 years ago)
Author:
BJ Burg
Message:

Web Inspector: disambiguate the various identifier and connection types in RemoteInspector
​https://bugs.webkit.org/show_bug.cgi?id=154130

Reviewed by Joseph Pecoraro.

There are multiple identifier types:

  • connection identifier, a string UUID for a remote debugger process.
  • session identifier, a string UUID for a remote driver/debugger instance.
  • page/target identifier, a number unique within a single process.

There are multiple connection types:

  • RemoteInspectorXPCConnection, a connection from RemoteInspectorXPCConnectionor to a relay.
  • RemoteConnectionToTarget, a class that bridges to targets' dispatch queues.

Use consistent variable and getter names so that these don't get confused and
so that the code is easier to read. This is especially an improvement when working
with multiple target types or connection types within the same function.

  • inspector/remote/RemoteConnectionToTarget.h:
  • inspector/remote/RemoteConnectionToTarget.mm:

Remove the member for m_identifier since we can ask the target for its target identifier
or use a default value via WTF::Optional. There's no reason to cache the value.

(Inspector::RemoteTargetHandleRunSourceWithInfo):
(Inspector::RemoteConnectionToTarget::targetIdentifier):
(Inspector::RemoteConnectionToTarget::destination):
(Inspector::RemoteConnectionToTarget::setup):
(Inspector::RemoteConnectionToTarget::sendMessageToFrontend):
Bail out if the target pointer was somehow cleared and we can't get a useful target identifier.

(Inspector::RemoteConnectionToTarget::RemoteConnectionToTarget): Deleted.

  • inspector/remote/RemoteControllableTarget.h:
  • inspector/remote/RemoteInspectionTarget.cpp:

(Inspector::RemoteInspectionTarget::pauseWaitingForAutomaticInspection):
(Inspector::RemoteInspectionTarget::unpauseForInitializedInspector):

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

(Inspector::RemoteInspector::nextAvailableTargetIdentifier):
(Inspector::RemoteInspector::registerTarget):
(Inspector::RemoteInspector::unregisterTarget):
(Inspector::RemoteInspector::updateTarget):
(Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
(Inspector::RemoteInspector::sendAutomaticInspectionCandidateMessage):
(Inspector::RemoteInspector::sendMessageToRemote):
(Inspector::RemoteInspector::setupFailed):
(Inspector::RemoteInspector::setupCompleted):
(Inspector::RemoteInspector::stopInternal):
(Inspector::RemoteInspector::setupXPCConnectionIfNeeded):
(Inspector::RemoteInspector::xpcConnectionFailed):
(Inspector::RemoteInspector::listingForInspectionTarget):
(Inspector::RemoteInspector::listingForAutomationTarget):
(Inspector::RemoteInspector::pushListingsNow):
(Inspector::RemoteInspector::pushListingsSoon):
(Inspector::RemoteInspector::updateHasActiveDebugSession):
(Inspector::RemoteInspector::receivedSetupMessage):
(Inspector::RemoteInspector::receivedDataMessage):
(Inspector::RemoteInspector::receivedDidCloseMessage):
(Inspector::RemoteInspector::receivedIndicateMessage):
(Inspector::RemoteInspector::receivedProxyApplicationSetupMessage):
(Inspector::RemoteInspector::receivedConnectionDiedMessage):
(Inspector::RemoteInspector::receivedAutomaticInspectionRejectMessage):
(Inspector::RemoteInspector::nextAvailableIdentifier): Deleted.

  • inspector/remote/RemoteInspectorConstants.h:
Location:
trunk/Source/JavaScriptCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r196513 r196515  
     12016-02-12  Brian Burg  <bburg@apple.com>
     2
     3        Web Inspector: disambiguate the various identifier and connection types in RemoteInspector
     4        https://bugs.webkit.org/show_bug.cgi?id=154130
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        There are multiple identifier types:
     9            - connection identifier, a string UUID for a remote debugger process.
     10            - session identifier, a string UUID for a remote driver/debugger instance.
     11            - page/target identifier, a number unique within a single process.
     12
     13        There are multiple connection types:
     14            - RemoteInspectorXPCConnection, a connection from RemoteInspectorXPCConnectionor to a relay.
     15            - RemoteConnectionToTarget, a class that bridges to targets' dispatch queues.
     16
     17        Use consistent variable and getter names so that these don't get confused and
     18        so that the code is easier to read. This is especially an improvement when working
     19        with multiple target types or connection types within the same function.
     20
     21        * inspector/remote/RemoteConnectionToTarget.h:
     22        * inspector/remote/RemoteConnectionToTarget.mm:
     23        Remove the member for m_identifier since we can ask the target for its target identifier
     24        or use a default value via WTF::Optional. There's no reason to cache the value.
     25
     26        (Inspector::RemoteTargetHandleRunSourceWithInfo):
     27        (Inspector::RemoteConnectionToTarget::targetIdentifier):
     28        (Inspector::RemoteConnectionToTarget::destination):
     29        (Inspector::RemoteConnectionToTarget::setup):
     30        (Inspector::RemoteConnectionToTarget::sendMessageToFrontend):
     31        Bail out if the target pointer was somehow cleared and we can't get a useful target identifier.
     32
     33        (Inspector::RemoteConnectionToTarget::RemoteConnectionToTarget): Deleted.
     34        * inspector/remote/RemoteControllableTarget.h:
     35        * inspector/remote/RemoteInspectionTarget.cpp:
     36        (Inspector::RemoteInspectionTarget::pauseWaitingForAutomaticInspection):
     37        (Inspector::RemoteInspectionTarget::unpauseForInitializedInspector):
     38        * inspector/remote/RemoteInspector.h:
     39        * inspector/remote/RemoteInspector.mm:
     40        (Inspector::RemoteInspector::nextAvailableTargetIdentifier):
     41        (Inspector::RemoteInspector::registerTarget):
     42        (Inspector::RemoteInspector::unregisterTarget):
     43        (Inspector::RemoteInspector::updateTarget):
     44        (Inspector::RemoteInspector::updateAutomaticInspectionCandidate):
     45        (Inspector::RemoteInspector::sendAutomaticInspectionCandidateMessage):
     46        (Inspector::RemoteInspector::sendMessageToRemote):
     47        (Inspector::RemoteInspector::setupFailed):
     48        (Inspector::RemoteInspector::setupCompleted):
     49        (Inspector::RemoteInspector::stopInternal):
     50        (Inspector::RemoteInspector::setupXPCConnectionIfNeeded):
     51        (Inspector::RemoteInspector::xpcConnectionFailed):
     52        (Inspector::RemoteInspector::listingForInspectionTarget):
     53        (Inspector::RemoteInspector::listingForAutomationTarget):
     54        (Inspector::RemoteInspector::pushListingsNow):
     55        (Inspector::RemoteInspector::pushListingsSoon):
     56        (Inspector::RemoteInspector::updateHasActiveDebugSession):
     57        (Inspector::RemoteInspector::receivedSetupMessage):
     58        (Inspector::RemoteInspector::receivedDataMessage):
     59        (Inspector::RemoteInspector::receivedDidCloseMessage):
     60        (Inspector::RemoteInspector::receivedIndicateMessage):
     61        (Inspector::RemoteInspector::receivedProxyApplicationSetupMessage):
     62        (Inspector::RemoteInspector::receivedConnectionDiedMessage):
     63        (Inspector::RemoteInspector::receivedAutomaticInspectionRejectMessage):
     64        (Inspector::RemoteInspector::nextAvailableIdentifier): Deleted.
     65        * inspector/remote/RemoteInspectorConstants.h:
     66
    1672016-02-12  Benjamin Poulain  <benjamin@webkit.org>
    268

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

    r194665 r196515  
    5555    virtual void targetClosed();
    5656
    57     unsigned identifier() const { return m_identifier; }
     57    Optional<unsigned> targetIdentifier() const;
    5858    NSString *connectionIdentifier() const;
    5959    NSString *destination() const;
    … …  
    8787
    8888    RemoteControllableTarget* m_target { nullptr };
    89     unsigned m_identifier { 0 };
    9089    RetainPtr<NSString> m_connectionIdentifier;
    9190    RetainPtr<NSString> m_destination;

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

    r194665 r196515  
    3333#import "RemoteInspectionTarget.h"
    3434#import <dispatch/dispatch.h>
     35#import <wtf/Optional.h>
    3536#import <wtf/Vector.h>
    3637
    … …  
    9394static void RemoteTargetHandleRunSourceWithInfo(void* info)
    9495{
    95     RemoteConnectionToTarget *connection = static_cast<RemoteConnectionToTarget*>(info);
     96    RemoteConnectionToTarget *connectionToTarget = static_cast<RemoteConnectionToTarget*>(info);
    9697
    9798    RemoteTargetQueue queueCopy;
    9899    {
    99         std::lock_guard<Lock> lock(connection->queueMutex());
    100         queueCopy = connection->queue();
    101         connection->clearQueue();
     100        std::lock_guard<Lock> lock(connectionToTarget->queueMutex());
     101        queueCopy = connectionToTarget->queue();
     102        connectionToTarget->clearQueue();
    102103    }
    103104
    … …  
    109110RemoteConnectionToTarget::RemoteConnectionToTarget(RemoteControllableTarget* target, NSString *connectionIdentifier, NSString *destination)
    110111    : m_target(target)
    111     , m_identifier(target->identifier())
    112112    , m_connectionIdentifier(connectionIdentifier)
    113113    , m_destination(destination)
    … …  
    121121}
    122122
     123Optional<unsigned> RemoteConnectionToTarget::targetIdentifier() const
     124{
     125    return m_target ? Optional<unsigned>(m_target->targetIdentifier()) : Nullopt;
     126}
     127
     128NSString *RemoteConnectionToTarget::connectionIdentifier() const
     129{
     130    return [[m_connectionIdentifier copy] autorelease];
     131}
     132
    123133NSString *RemoteConnectionToTarget::destination() const
    124134{
    125135    return [[m_destination copy] autorelease];
    126 }
    127 
    128 NSString *RemoteConnectionToTarget::connectionIdentifier() const
    129 {
    130     return [[m_connectionIdentifier copy] autorelease];
    131136}
    132137
    … …  
    160165            std::lock_guard<Lock> lock(m_targetMutex);
    161166            if (!m_target || !m_target->remoteControlAllowed()) {
    162                 RemoteInspector::singleton().setupFailed(m_identifier);
     167                RemoteInspector::singleton().setupFailed(targetIdentifier().valueOr(0));
    163168                m_target = nullptr;
    164169            } else if (is<RemoteInspectionTarget>(m_target)) {
    … …  
    227232bool RemoteConnectionToTarget::sendMessageToFrontend(const String& message)
    228233{
    229     RemoteInspector::singleton().sendMessageToRemote(identifier(), message);
    230 
     234    if (!m_target)
     235        return false;
     236
     237    RemoteInspector::singleton().sendMessageToRemote(targetIdentifier().value(), message);
    231238    return true;
    232239}

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

    r192753 r196515  
    4747    virtual void disconnect(FrontendChannel*) = 0;
    4848
    49     unsigned identifier() const { return m_identifier; }
    50     void setIdentifier(unsigned identifier) { m_identifier = identifier; }
     49    unsigned targetIdentifier() const { return m_identifier; }
     50    void setTargetIdentifier(unsigned identifier) { m_identifier = identifier; }
    5151
    5252    enum class Type { JavaScript, Web, Automation };

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

    r192753 r196515  
    5454void RemoteInspectionTarget::pauseWaitingForAutomaticInspection()
    5555{
    56     ASSERT(identifier());
     56    ASSERT(targetIdentifier());
    5757    ASSERT(m_allowed);
    5858    ASSERT(automaticInspectionAllowed());
    5959
    6060    EventLoop loop;
    61     while (RemoteInspector::singleton().waitingForAutomaticInspection(identifier()) && !loop.ended())
     61    while (RemoteInspector::singleton().waitingForAutomaticInspection(targetIdentifier()) && !loop.ended())
    6262        loop.cycle();
    6363}
    … …  
    6565void RemoteInspectionTarget::unpauseForInitializedInspector()
    6666{
    67     RemoteInspector::singleton().setupCompleted(identifier());
     67    RemoteInspector::singleton().setupCompleted(targetIdentifier());
    6868}
    6969

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

    r194646 r196515  
    6363    void unregisterTarget(RemoteControllableTarget*);
    6464    void updateTarget(RemoteControllableTarget*);
    65     void sendMessageToRemote(unsigned identifier, const String& message);
     65    void sendMessageToRemote(unsigned targetIdentifier, const String& message);
    6666
    6767    void updateAutomaticInspectionCandidate(RemoteInspectionTarget*);
    6868    void setRemoteInspectorClient(RemoteInspector::Client*);
    6969
    70     void setupFailed(unsigned identifier);
    71     void setupCompleted(unsigned identifier);
    72     bool waitingForAutomaticInspection(unsigned identifier);
     70    void setupFailed(unsigned targetIdentifier);
     71    void setupCompleted(unsigned targetIdentifier);
     72    bool waitingForAutomaticInspection(unsigned targetIdentifier);
    7373    void clientCapabilitiesDidChange() { pushListingsSoon(); }
    7474
    … …  
    8888    RemoteInspector();
    8989
    90     unsigned nextAvailableIdentifier();
     90    unsigned nextAvailableTargetIdentifier();
    9191
    9292    enum class StopSource { API, XPCMessage };
    … …  
    128128
    129129    HashMap<unsigned, RemoteControllableTarget*> m_targetMap;
    130     HashMap<unsigned, RetainPtr<NSDictionary>> m_listingMap;
    131     HashMap<unsigned, RefPtr<RemoteConnectionToTarget>> m_connectionMap;
     130    HashMap<unsigned, RetainPtr<NSDictionary>> m_targetListingMap;
     131    HashMap<unsigned, RefPtr<RemoteConnectionToTarget>> m_targetConnectionMap;
    132132
    133     RefPtr<RemoteInspectorXPCConnection> m_xpcConnection;
     133    RefPtr<RemoteInspectorXPCConnection> m_relayConnection;
    134134
    135135    RemoteInspector::Client* m_client { nullptr };
    136136
    137137    dispatch_queue_t m_xpcQueue;
    138     unsigned m_nextAvailableIdentifier { 1 };
     138    unsigned m_nextAvailableTargetIdentifier { 1 };
    139139    int m_notifyToken { 0 };
    140140    bool m_enabled { false };
    … …  
    147147    bool m_automaticInspectionEnabled { false };
    148148    bool m_automaticInspectionPaused { false };
    149     unsigned m_automaticInspectionCandidateIdentifier { 0 };
     149    unsigned m_automaticInspectionCandidateTargetIdentifier { 0 };
    150150};
    151151

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

    r196454 r196515  
    102102}
    103103
    104 unsigned RemoteInspector::nextAvailableIdentifier()
    105 {
    106     unsigned nextValidIdentifier;
     104unsigned RemoteInspector::nextAvailableTargetIdentifier()
     105{
     106    unsigned nextValidTargetIdentifier;
    107107    do {
    108         nextValidIdentifier = m_nextAvailableIdentifier++;
    109     } while (!nextValidIdentifier || nextValidIdentifier == std::numeric_limits<unsigned>::max() || m_targetMap.contains(nextValidIdentifier));
    110     return nextValidIdentifier;
     108        nextValidTargetIdentifier = m_nextAvailableTargetIdentifier++;
     109    } while (!nextValidTargetIdentifier || nextValidTargetIdentifier == std::numeric_limits<unsigned>::max() || m_targetMap.contains(nextValidTargetIdentifier));
     110    return nextValidTargetIdentifier;
    111111}
    112112
    … …  
    117117    std::lock_guard<Lock> lock(m_mutex);
    118118
    119     unsigned identifier = nextAvailableIdentifier();
    120     target->setIdentifier(identifier);
     119    unsigned targetIdentifier = nextAvailableTargetIdentifier();
     120    target->setTargetIdentifier(targetIdentifier);
    121121
    122122    {
    123         auto result = m_targetMap.set(identifier, target);
     123        auto result = m_targetMap.set(targetIdentifier, target);
    124124        ASSERT_UNUSED(result, result.isNewEntry);
    125125    }
    126    
     126
    127127    // If remote control is not allowed, a null listing is returned.
    128     if (RetainPtr<NSDictionary> listing = listingForTarget(*target)) {
    129         auto result = m_listingMap.set(identifier, listing);
     128    if (RetainPtr<NSDictionary> targetListing = listingForTarget(*target)) {
     129        auto result = m_targetListingMap.set(targetIdentifier, targetListing);
    130130        ASSERT_UNUSED(result, result.isNewEntry);
    131131    }
    … …  
    140140    std::lock_guard<Lock> lock(m_mutex);
    141141
    142     unsigned identifier = target->identifier();
    143     if (!identifier)
    144         return;
    145 
    146     bool wasRemoved = m_targetMap.remove(identifier);
     142    unsigned targetIdentifier = target->targetIdentifier();
     143    if (!targetIdentifier)
     144        return;
     145
     146    bool wasRemoved = m_targetMap.remove(targetIdentifier);
    147147    ASSERT_UNUSED(wasRemoved, wasRemoved);
    148148
    149149    // The listing may never have been added if remote control isn't allowed.
    150     m_listingMap.remove(identifier);
    151 
    152     if (auto connection = m_connectionMap.take(identifier))
    153         connection->targetClosed();
     150    m_targetListingMap.remove(targetIdentifier);
     151
     152    if (auto connectionToTarget = m_targetConnectionMap.take(targetIdentifier))
     153        connectionToTarget->targetClosed();
    154154
    155155    pushListingsSoon();
    … …  
    162162    std::lock_guard<Lock> lock(m_mutex);
    163163
    164     unsigned identifier = target->identifier();
    165     if (!identifier)
     164    unsigned targetIdentifier = target->targetIdentifier();
     165    if (!targetIdentifier)
    166166        return;
    167167
    168168    {
    169         auto result = m_targetMap.set(identifier, target);
     169        auto result = m_targetMap.set(targetIdentifier, target);
    170170        ASSERT_UNUSED(result, !result.isNewEntry);
    171171    }
    172172
    173173    // If the target has just allowed remote control, then the listing won't exist yet.
    174     if (RetainPtr<NSDictionary> listing = listingForTarget(*target))
    175         m_listingMap.set(identifier, listing);
     174    if (RetainPtr<NSDictionary> targetListing = listingForTarget(*target))
     175        m_targetListingMap.set(targetIdentifier, targetListing);
    176176
    177177    pushListingsSoon();
    … …  
    184184        std::lock_guard<Lock> lock(m_mutex);
    185185
    186         unsigned identifier = target->identifier();
    187         if (!identifier)
     186        unsigned targetIdentifier = target->targetIdentifier();
     187        if (!targetIdentifier)
    188188            return;
    189189
    190         auto result = m_targetMap.set(identifier, target);
     190        auto result = m_targetMap.set(targetIdentifier, target);
    191191        ASSERT_UNUSED(result, !result.isNewEntry);
    192192
    193193        // If the target has just allowed remote control, then the listing won't exist yet.
    194         if (RetainPtr<NSDictionary> listing = listingForTarget(*target))
    195             m_listingMap.set(identifier, listing);
     194        if (RetainPtr<NSDictionary> targetListing = listingForTarget(*target))
     195            m_targetListingMap.set(targetIdentifier, targetListing);
    196196
    197197        // Don't allow automatic inspection unless it is allowed or we are stopped.
    … …  
    202202
    203203        // FIXME: We should handle multiple debuggables trying to pause at the same time on different threads.
    204         // To make this work we will need to change m_automaticInspectionCandidateIdentifier to be a per-thread value.
     204        // To make this work we will need to change m_automaticInspectionCandidateTargetIdentifier to be a per-thread value.
    205205        // Multiple attempts on the same thread should not be possible because our nested run loop is in a special RWI mode.
    206206        if (m_automaticInspectionPaused) {
    207             LOG_ERROR("Skipping Automatic Inspection Candidate with pageId(%u) because we are already paused waiting for pageId(%u)", identifier, m_automaticInspectionCandidateIdentifier);
     207            LOG_ERROR("Skipping Automatic Inspection Candidate with pageId(%u) because we are already paused waiting for pageId(%u)", targetIdentifier, m_automaticInspectionCandidateTargetIdentifier);
    208208            pushListingsSoon();
    209209            return;
    … …  
    211211
    212212        m_automaticInspectionPaused = true;
    213         m_automaticInspectionCandidateIdentifier = identifier;
     213        m_automaticInspectionCandidateTargetIdentifier = targetIdentifier;
    214214
    215215        // If we are pausing before we have connected to webinspectord the candidate message will be sent as soon as the connection is established.
    216         if (m_xpcConnection) {
     216        if (m_relayConnection) {
    217217            pushListingsNow();
    218218            sendAutomaticInspectionCandidateMessage();
    … …  
    222222        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.8 * NSEC_PER_SEC), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    223223            std::lock_guard<Lock> lock(m_mutex);
    224             if (m_automaticInspectionCandidateIdentifier == identifier) {
    225                 LOG_ERROR("Skipping Automatic Inspection Candidate with pageId(%u) because we failed to receive a response in time.", m_automaticInspectionCandidateIdentifier);
     224            if (m_automaticInspectionCandidateTargetIdentifier == targetIdentifier) {
     225                LOG_ERROR("Skipping Automatic Inspection Candidate with pageId(%u) because we failed to receive a response in time.", m_automaticInspectionCandidateTargetIdentifier);
    226226                m_automaticInspectionPaused = false;
    227227            }
    … …  
    234234        std::lock_guard<Lock> lock(m_mutex);
    235235
    236         ASSERT(m_automaticInspectionCandidateIdentifier);
    237         m_automaticInspectionCandidateIdentifier = 0;
     236        ASSERT(m_automaticInspectionCandidateTargetIdentifier);
     237        m_automaticInspectionCandidateTargetIdentifier = 0;
    238238    }
    239239}
    … …  
    256256    ASSERT(m_automaticInspectionEnabled);
    257257    ASSERT(m_automaticInspectionPaused);
    258     ASSERT(m_automaticInspectionCandidateIdentifier);
    259     ASSERT(m_xpcConnection);
    260 
    261     NSDictionary *details = @{WIRPageIdentifierKey: @(m_automaticInspectionCandidateIdentifier)};
    262     m_xpcConnection->sendMessage(WIRAutomaticInspectionCandidateMessage, details);
    263 }
    264 
    265 void RemoteInspector::sendMessageToRemote(unsigned identifier, const String& message)
    266 {
    267     std::lock_guard<Lock> lock(m_mutex);
    268 
    269     if (!m_xpcConnection)
    270         return;
    271 
    272     auto connection = m_connectionMap.get(identifier);
    273     if (!connection)
     258    ASSERT(m_automaticInspectionCandidateTargetIdentifier);
     259    ASSERT(m_relayConnection);
     260
     261    NSDictionary *details = @{WIRTargetIdentifierKey: @(m_automaticInspectionCandidateTargetIdentifier)};
     262    m_relayConnection->sendMessage(WIRAutomaticInspectionCandidateMessage, details);
     263}
     264
     265void RemoteInspector::sendMessageToRemote(unsigned targetIdentifier, const String& message)
     266{
     267    std::lock_guard<Lock> lock(m_mutex);
     268
     269    if (!m_relayConnection)
     270        return;
     271
     272    auto targetConnection = m_targetConnectionMap.get(targetIdentifier);
     273    if (!targetConnection)
    274274        return;
    275275
    276276    NSDictionary *userInfo = @{
    277277        WIRRawDataKey: [static_cast<NSString *>(message) dataUsingEncoding:NSUTF8StringEncoding],
    278         WIRConnectionIdentifierKey: connection->connectionIdentifier(),
    279         WIRDestinationKey: connection->destination()
     278        WIRConnectionIdentifierKey: targetConnection->connectionIdentifier(),
     279        WIRDestinationKey: targetConnection->destination()
    280280    };
    281281
    282     m_xpcConnection->sendMessage(WIRRawDataMessage, userInfo);
    283 }
    284 
    285 void RemoteInspector::setupFailed(unsigned identifier)
    286 {
    287     std::lock_guard<Lock> lock(m_mutex);
    288 
    289     m_connectionMap.remove(identifier);
     282    m_relayConnection->sendMessage(WIRRawDataMessage, userInfo);
     283}
     284
     285void RemoteInspector::setupFailed(unsigned targetIdentifier)
     286{
     287    std::lock_guard<Lock> lock(m_mutex);
     288
     289    m_targetConnectionMap.remove(targetIdentifier);
    290290
    291291    updateHasActiveDebugSession();
    292292
    293     if (identifier == m_automaticInspectionCandidateIdentifier)
     293    if (targetIdentifier == m_automaticInspectionCandidateTargetIdentifier)
    294294        m_automaticInspectionPaused = false;
    295295
    … …  
    297297}
    298298
    299 void RemoteInspector::setupCompleted(unsigned identifier)
    300 {
    301     std::lock_guard<Lock> lock(m_mutex);
    302 
    303     if (identifier == m_automaticInspectionCandidateIdentifier)
     299void RemoteInspector::setupCompleted(unsigned targetIdentifier)
     300{
     301    std::lock_guard<Lock> lock(m_mutex);
     302
     303    if (targetIdentifier == m_automaticInspectionCandidateTargetIdentifier)
    304304        m_automaticInspectionPaused = false;
    305305}
    … …  
    349349    m_pushScheduled = false;
    350350
    351     for (auto connection : m_connectionMap.values())
    352         connection->close();
    353     m_connectionMap.clear();
     351    for (auto targetConnection : m_targetConnectionMap.values())
     352        targetConnection->close();
     353    m_targetConnectionMap.clear();
    354354
    355355    updateHasActiveDebugSession();
    … …  
    357357    m_automaticInspectionPaused = false;
    358358
    359     if (m_xpcConnection) {
     359    if (m_relayConnection) {
    360360        switch (source) {
    361361        case StopSource::API:
    362             m_xpcConnection->close();
     362            m_relayConnection->close();
    363363            break;
    364364        case StopSource::XPCMessage:
    365             m_xpcConnection->closeFromMessage();
     365            m_relayConnection->closeFromMessage();
    366366            break;
    367367        }
    368368
    369         m_xpcConnection = nullptr;
     369        m_relayConnection = nullptr;
    370370    }
    371371
    … …  
    377377    std::lock_guard<Lock> lock(m_mutex);
    378378
    379     if (m_xpcConnection)
     379    if (m_relayConnection)
    380380        return;
    381381
    … …  
    384384        return;
    385385
    386     m_xpcConnection = adoptRef(new RemoteInspectorXPCConnection(connection, m_xpcQueue, this));
    387     m_xpcConnection->sendMessage(@"syn", nil); // Send a simple message to initialize the XPC connection.
     386    m_relayConnection = adoptRef(new RemoteInspectorXPCConnection(connection, m_xpcQueue, this));
     387    m_relayConnection->sendMessage(@"syn", nil); // Send a simple message to initialize the XPC connection.
    388388    xpc_release(connection);
    389389
    390     if (m_automaticInspectionCandidateIdentifier) {
     390    if (m_automaticInspectionCandidateTargetIdentifier) {
    391391        // We already have a debuggable waiting to be automatically inspected.
    392392        pushListingsNow();
    … …  
    445445}
    446446
    447 void RemoteInspector::xpcConnectionFailed(RemoteInspectorXPCConnection* connection)
    448 {
    449     std::lock_guard<Lock> lock(m_mutex);
    450 
    451     ASSERT(connection == m_xpcConnection);
    452     if (connection != m_xpcConnection)
     447void RemoteInspector::xpcConnectionFailed(RemoteInspectorXPCConnection* relayConnection)
     448{
     449    std::lock_guard<Lock> lock(m_mutex);
     450
     451    ASSERT(relayConnection == m_relayConnection);
     452    if (relayConnection != m_relayConnection)
    453453        return;
    454454
    455455    m_pushScheduled = false;
    456456
    457     for (auto connection : m_connectionMap.values())
    458         connection->close();
    459     m_connectionMap.clear();
     457    for (auto targetConnection : m_targetConnectionMap.values())
     458        targetConnection->close();
     459    m_targetConnectionMap.clear();
    460460
    461461    updateHasActiveDebugSession();
    … …  
    463463    m_automaticInspectionPaused = false;
    464464
    465     // The connection will close itself.
    466     m_xpcConnection = nullptr;
     465    // The XPC connection will close itself.
     466    m_relayConnection = nullptr;
    467467}
    468468
    … …  
    494494
    495495    RetainPtr<NSMutableDictionary> listing = adoptNS([[NSMutableDictionary alloc] init]);
    496     [listing setObject:@(target.identifier()) forKey:WIRPageIdentifierKey];
     496    [listing setObject:@(target.targetIdentifier()) forKey:WIRTargetIdentifierKey];
    497497
    498498    switch (target.type()) {
    … …  
    511511    }
    512512
    513     if (auto* connection = m_connectionMap.get(target.identifier()))
    514         [listing setObject:connection->connectionIdentifier() forKey:WIRConnectionIdentifierKey];
     513    if (auto* connectionToTarget = m_targetConnectionMap.get(target.targetIdentifier()))
     514        [listing setObject:connectionToTarget->connectionIdentifier() forKey:WIRConnectionIdentifierKey];
    515515
    516516    if (target.hasLocalDebugger())
    … …  
    527527
    528528    RetainPtr<NSMutableDictionary> listing = adoptNS([[NSMutableDictionary alloc] init]);
    529     [listing setObject:@(target.identifier()) forKey:WIRPageIdentifierKey];
     529    [listing setObject:@(target.targetIdentifier()) forKey:WIRTargetIdentifierKey];
    530530    [listing setObject:target.name() forKey:WIRTitleKey];
    531531    [listing setObject:WIRTypeAutomation forKey:WIRTypeKey];
    532532    [listing setObject:@(target.isPaired()) forKey:WIRAutomationTargetIsPairedKey];
    533533
    534     if (auto connection = m_connectionMap.get(target.identifier()))
    535         [listing setObject:connection->connectionIdentifier() forKey:WIRConnectionIdentifierKey];
     534    if (auto connectionToTarget = m_targetConnectionMap.get(target.targetIdentifier()))
     535        [listing setObject:connectionToTarget->connectionIdentifier() forKey:WIRConnectionIdentifierKey];
    536536
    537537    return listing;
    … …  
    540540void RemoteInspector::pushListingsNow()
    541541{
    542     ASSERT(m_xpcConnection);
    543     if (!m_xpcConnection)
     542    ASSERT(m_relayConnection);
     543    if (!m_relayConnection)
    544544        return;
    545545
    … …  
    547547
    548548    RetainPtr<NSMutableDictionary> listings = adoptNS([[NSMutableDictionary alloc] init]);
    549     for (RetainPtr<NSDictionary> listing : m_listingMap.values()) {
    550         NSString *identifier = [[listing.get() objectForKey:WIRPageIdentifierKey] stringValue];
    551         [listings setObject:listing.get() forKey:identifier];
     549    for (RetainPtr<NSDictionary> listing : m_targetListingMap.values()) {
     550        NSString *targetIdentifierString = [[listing.get() objectForKey:WIRTargetIdentifierKey] stringValue];
     551        [listings setObject:listing.get() forKey:targetIdentifierString];
    552552    }
    553553
    … …  
    558558    [message setObject:@(isAllowed) forKey:WIRRemoteAutomationEnabledKey];
    559559
    560     m_xpcConnection->sendMessage(WIRListingMessage, message.get());
     560    m_relayConnection->sendMessage(WIRListingMessage, message.get());
    561561}
    562562
    563563void RemoteInspector::pushListingsSoon()
    564564{
    565     if (!m_xpcConnection)
     565    if (!m_relayConnection)
    566566        return;
    567567
    … …  
    581581void RemoteInspector::updateHasActiveDebugSession()
    582582{
    583     bool hasActiveDebuggerSession = !m_connectionMap.isEmpty();
     583    bool hasActiveDebuggerSession = !m_targetConnectionMap.isEmpty();
    584584    if (hasActiveDebuggerSession == m_hasActiveDebugSession)
    585585        return;
    … …  
    596596void RemoteInspector::receivedSetupMessage(NSDictionary *userInfo)
    597597{
    598     unsigned identifier = [[userInfo objectForKey:WIRPageIdentifierKey] unsignedIntegerValue];
    599     if (!identifier)
     598    unsigned targetIdentifier = [[userInfo objectForKey:WIRTargetIdentifierKey] unsignedIntegerValue];
     599    if (!targetIdentifier)
    600600        return;
    601601
    … …  
    608608        return;
    609609
    610     if (m_connectionMap.contains(identifier))
    611         return;
    612 
    613     auto findResult = m_targetMap.find(identifier);
     610    if (m_targetConnectionMap.contains(targetIdentifier))
     611        return;
     612
     613    auto findResult = m_targetMap.find(targetIdentifier);
    614614    if (findResult == m_targetMap.end())
    615615        return;
    … …  
    617617    // Attempt to create a connection. This may fail if the page already has an inspector or if it disallows inspection.
    618618    RemoteControllableTarget* target = findResult->value;
    619     RefPtr<RemoteConnectionToTarget> connection = adoptRef(new RemoteConnectionToTarget(downcast<RemoteInspectionTarget>(target), connectionIdentifier, sender));
     619    RefPtr<RemoteConnectionToTarget> connectionToTarget = adoptRef(new RemoteConnectionToTarget(downcast<RemoteInspectionTarget>(target), connectionIdentifier, sender));
    620620
    621621    if (is<RemoteInspectionTarget>(target)) {
    622         bool isAutomaticInspection = m_automaticInspectionCandidateIdentifier == target->identifier();
     622        bool isAutomaticInspection = m_automaticInspectionCandidateTargetIdentifier == target->targetIdentifier();
    623623        bool automaticallyPause = [[userInfo objectForKey:WIRAutomaticallyPause] boolValue];
    624624
    625         if (!connection->setup(isAutomaticInspection, automaticallyPause)) {
    626             connection->close();
     625        if (!connectionToTarget->setup(isAutomaticInspection, automaticallyPause)) {
     626            connectionToTarget->close();
    627627            return;
    628628        }
    629         m_connectionMap.set(identifier, connection.release());
     629        m_targetConnectionMap.set(targetIdentifier, connectionToTarget.release());
    630630        updateHasActiveDebugSession();
    631631    } else if (is<RemoteAutomationTarget>(target)) {
    632         if (!connection->setup()) {
    633             connection->close();
     632        if (!connectionToTarget->setup()) {
     633            connectionToTarget->close();
    634634            return;
    635635        }
    636         m_connectionMap.set(identifier, connection.release());
     636        m_targetConnectionMap.set(targetIdentifier, connectionToTarget.release());
    637637        updateHasActiveDebugSession();
    638638    } else
    … …  
    644644void RemoteInspector::receivedDataMessage(NSDictionary *userInfo)
    645645{
    646     unsigned identifier = [[userInfo objectForKey:WIRPageIdentifierKey] unsignedIntegerValue];
    647     if (!identifier)
    648         return;
    649 
    650     auto connection = m_connectionMap.get(identifier);
    651     if (!connection)
     646    unsigned targetIdentifier = [[userInfo objectForKey:WIRTargetIdentifierKey] unsignedIntegerValue];
     647    if (!targetIdentifier)
     648        return;
     649
     650    auto connectionToTarget = m_targetConnectionMap.get(targetIdentifier);
     651    if (!connectionToTarget)
    652652        return;
    653653
    654654    NSData *data = [userInfo objectForKey:WIRSocketDataKey];
    655655    RetainPtr<NSString> message = adoptNS([[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
    656     connection->sendMessageToTarget(message.get());
     656    connectionToTarget->sendMessageToTarget(message.get());
    657657}
    658658
    659659void RemoteInspector::receivedDidCloseMessage(NSDictionary *userInfo)
    660660{
    661     unsigned identifier = [[userInfo objectForKey:WIRPageIdentifierKey] unsignedIntegerValue];
    662     if (!identifier)
     661    unsigned targetIdentifier = [[userInfo objectForKey:WIRTargetIdentifierKey] unsignedIntegerValue];
     662    if (!targetIdentifier)
    663663        return;
    664664
    … …  
    667667        return;
    668668
    669     auto connection = m_connectionMap.get(identifier);
    670     if (!connection)
    671         return;
    672 
    673     if (![connectionIdentifier isEqualToString:connection->connectionIdentifier()])
    674         return;
    675 
    676     connection->close();
    677     m_connectionMap.remove(identifier);
     669    auto connectionToTarget = m_targetConnectionMap.get(targetIdentifier);
     670    if (!connectionToTarget)
     671        return;
     672
     673    if (![connectionIdentifier isEqualToString:connectionToTarget->connectionIdentifier()])
     674        return;
     675
     676    connectionToTarget->close();
     677    m_targetConnectionMap.remove(targetIdentifier);
    678678
    679679    updateHasActiveDebugSession();
    … …  
    689689void RemoteInspector::receivedIndicateMessage(NSDictionary *userInfo)
    690690{
    691     unsigned identifier = [[userInfo objectForKey:WIRPageIdentifierKey] unsignedIntegerValue];
     691    unsigned identifier = [[userInfo objectForKey:WIRTargetIdentifierKey] unsignedIntegerValue];
    692692    if (!identifier)
    693693        return;
    … …  
    713713void RemoteInspector::receivedProxyApplicationSetupMessage(NSDictionary *)
    714714{
    715     ASSERT(m_xpcConnection);
    716     if (!m_xpcConnection)
     715    ASSERT(m_relayConnection);
     716    if (!m_relayConnection)
    717717        return;
    718718
    … …  
    731731    m_shouldSendParentProcessInformation = false;
    732732
    733     m_xpcConnection->sendMessage(WIRProxyApplicationSetupResponseMessage, @{
     733    m_relayConnection->sendMessage(WIRProxyApplicationSetupResponseMessage, @{
    734734        WIRProxyApplicationParentPIDKey: @(m_parentProcessIdentifier),
    735735        WIRProxyApplicationParentAuditDataKey: (NSData *)m_parentProcessAuditData.get(),
    … …  
    743743        return;
    744744
    745     auto it = m_connectionMap.begin();
    746     auto end = m_connectionMap.end();
     745    auto it = m_targetConnectionMap.begin();
     746    auto end = m_targetConnectionMap.end();
    747747    for (; it != end; ++it) {
    748748        if ([connectionIdentifier isEqualToString:it->value->connectionIdentifier()])
    … …  
    755755    auto connection = it->value;
    756756    connection->close();
    757     m_connectionMap.remove(it);
     757    m_targetConnectionMap.remove(it);
    758758
    759759    updateHasActiveDebugSession();
    … …  
    770770void RemoteInspector::receivedAutomaticInspectionRejectMessage(NSDictionary *userInfo)
    771771{
    772     unsigned rejectionIdentifier = [[userInfo objectForKey:WIRPageIdentifierKey] unsignedIntValue];
    773 
    774     ASSERT(rejectionIdentifier == m_automaticInspectionCandidateIdentifier);
    775     if (rejectionIdentifier == m_automaticInspectionCandidateIdentifier)
     772    unsigned rejectionIdentifier = [[userInfo objectForKey:WIRTargetIdentifierKey] unsignedIntValue];
     773
     774    ASSERT(rejectionIdentifier == m_automaticInspectionCandidateTargetIdentifier);
     775    if (rejectionIdentifier == m_automaticInspectionCandidateTargetIdentifier)
    776776        m_automaticInspectionPaused = false;
    777777}

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

    r196454 r196515  
    4949#define WIRHostApplicationNameKey               @"WIRHostApplicationNameKey"
    5050#define WIRConnectionIdentifierKey              @"WIRConnectionIdentifierKey"
    51 #define WIRPageIdentifierKey                    @"WIRPageIdentifierKey"
     51// COMPATABILITY(iOS 9): The key string is intentionally mismatched to support old relays.
     52#define WIRTargetIdentifierKey                  @"WIRPageIdentifierKey"
    5253#define WIRHasLocalDebuggerKey                  @"WIRHasLocalDebuggerKey"
    5354#define WIRTitleKey                             @"WIRTitleKey"
Note: See TracChangeset for help on using the changeset viewer.