RemoteConnectionToTarget.h [plain text]
#if ENABLE(REMOTE_INSPECTOR)
#ifndef RemoteConnectionToTarget_h
#define RemoteConnectionToTarget_h
#import "InspectorFrontendChannel.h"
#import "RemoteConnectionToTarget.h"
#import "RemoteInspector.h"
#import <mutex>
#import <wtf/BlockPtr.h>
#import <wtf/Lock.h>
#import <wtf/RetainPtr.h>
#import <wtf/ThreadSafeRefCounted.h>
OBJC_CLASS NSString;
namespace Inspector {
typedef Vector<BlockPtr<void ()>> RemoteTargetQueue;
class RemoteConnectionToTarget final : public ThreadSafeRefCounted<RemoteConnectionToTarget>, public FrontendChannel {
public:
RemoteConnectionToTarget(RemoteControllableTarget*, NSString *connectionIdentifier, NSString *destination);
virtual ~RemoteConnectionToTarget();
bool setup(bool isAutomaticInspection = false, bool automaticallyPause = false);
virtual void sendMessageToTarget(NSString *);
virtual void close();
virtual void targetClosed();
Optional<unsigned> targetIdentifier() const;
NSString *connectionIdentifier() const;
NSString *destination() const;
Lock& queueMutex() { return m_queueMutex; }
const RemoteTargetQueue& queue() const { return m_queue; }
void clearQueue() { m_queue.clear(); }
ConnectionType connectionType() const override { return ConnectionType::Remote; }
bool sendMessageToFrontend(const String&) override;
private:
void dispatchAsyncOnTarget(void (^block)());
void setupRunLoop();
void teardownRunLoop();
void queueTaskOnPrivateRunLoop(void (^block)());
Lock m_targetMutex;
RetainPtr<CFRunLoopRef> m_runLoop;
RetainPtr<CFRunLoopSourceRef> m_runLoopSource;
RemoteTargetQueue m_queue;
Lock m_queueMutex;
RemoteControllableTarget* m_target { nullptr };
RetainPtr<NSString> m_connectionIdentifier;
RetainPtr<NSString> m_destination;
bool m_connected { false };
};
}
#endif // RemoteConnectionToTarget_h
#endif // ENABLE(REMOTE_INSPECTOR)