SimulatedInputDispatcher.h [plain text]
#pragma once
#if ENABLE(WEBDRIVER_ACTIONS_API)
#include <WebCore/FrameIdentifier.h>
#include <WebCore/IntPoint.h>
#include <WebCore/IntSize.h>
#include <wtf/CompletionHandler.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/Optional.h>
#include <wtf/RefCounted.h>
#include <wtf/RunLoop.h>
#include <wtf/Seconds.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>
namespace Inspector { namespace Protocol { namespace Automation {
enum class ErrorMessage;
enum class KeyboardInteractionType;
enum class MouseButton;
enum class MouseInteraction;
enum class MouseMoveOrigin;
enum class VirtualKey;
} } }
namespace WebKit {
class AutomationCommandError;
using AutomationCompletionHandler = WTF::CompletionHandler<void(Optional<AutomationCommandError>)>;
class WebPageProxy;
using KeyboardInteraction = Inspector::Protocol::Automation::KeyboardInteractionType;
using VirtualKey = Inspector::Protocol::Automation::VirtualKey;
using VirtualKeyMap = HashMap<VirtualKey, VirtualKey, WTF::IntHash<VirtualKey>, WTF::StrongEnumHashTraits<VirtualKey>>;
using CharKey = UChar32;
using CharKeySet = ListHashSet<CharKey>;
using MouseButton = Inspector::Protocol::Automation::MouseButton;
using MouseInteraction = Inspector::Protocol::Automation::MouseInteraction;
using MouseMoveOrigin = Inspector::Protocol::Automation::MouseMoveOrigin;
enum class SimulatedInputSourceType {
Null, Keyboard,
Mouse,
Touch,
Wheel,
Pen,
};
enum class TouchInteraction {
TouchDown,
MoveTo,
LiftUp,
};
struct SimulatedInputSourceState {
CharKeySet pressedCharKeys;
VirtualKeyMap pressedVirtualKeys;
Optional<MouseButton> pressedMouseButton;
Optional<MouseMoveOrigin> origin;
Optional<String> nodeHandle;
Optional<WebCore::IntPoint> location;
Optional<WebCore::IntSize> scrollDelta;
Optional<Seconds> duration;
static SimulatedInputSourceState emptyStateForSourceType(SimulatedInputSourceType);
};
struct SimulatedInputSource : public RefCounted<SimulatedInputSource> {
public:
SimulatedInputSourceType type;
SimulatedInputSourceState state;
static Ref<SimulatedInputSource> create(SimulatedInputSourceType type)
{
return adoptRef(*new SimulatedInputSource(type));
}
private:
SimulatedInputSource(SimulatedInputSourceType type)
: type(type)
, state(SimulatedInputSourceState::emptyStateForSourceType(type))
{ }
};
struct SimulatedInputKeyFrame {
public:
using StateEntry = std::pair<SimulatedInputSource&, SimulatedInputSourceState>;
explicit SimulatedInputKeyFrame(Vector<StateEntry>&&);
Seconds maximumDuration() const;
static SimulatedInputKeyFrame keyFrameFromStateOfInputSources(const HashMap<String, Ref<SimulatedInputSource>>&);
static SimulatedInputKeyFrame keyFrameToResetInputSources(const HashMap<String, Ref<SimulatedInputSource>>&);
Vector<StateEntry> states;
};
class SimulatedInputDispatcher : public RefCounted<SimulatedInputDispatcher> {
WTF_MAKE_NONCOPYABLE(SimulatedInputDispatcher);
public:
class Client {
public:
virtual ~Client() { }
#if ENABLE(WEBDRIVER_MOUSE_INTERACTIONS)
virtual void simulateMouseInteraction(WebPageProxy&, MouseInteraction, MouseButton, const WebCore::IntPoint& locationInView, const String& pointerType, AutomationCompletionHandler&&) = 0;
#endif
#if ENABLE(WEBDRIVER_TOUCH_INTERACTIONS)
virtual void simulateTouchInteraction(WebPageProxy&, TouchInteraction, const WebCore::IntPoint& locationInView, Optional<Seconds> duration, AutomationCompletionHandler&&) = 0;
#endif
#if ENABLE(WEBDRIVER_KEYBOARD_INTERACTIONS)
virtual void simulateKeyboardInteraction(WebPageProxy&, KeyboardInteraction, WTF::Variant<VirtualKey, CharKey>&&, AutomationCompletionHandler&&) = 0;
#endif
#if ENABLE(WEBDRIVER_WHEEL_INTERACTIONS)
virtual void simulateWheelInteraction(WebPageProxy&, const WebCore::IntPoint& locationInView, const WebCore::IntSize& delta, AutomationCompletionHandler&&) = 0;
#endif
virtual void viewportInViewCenterPointOfElement(WebPageProxy&, Optional<WebCore::FrameIdentifier>, const String& nodeHandle, Function<void (Optional<WebCore::IntPoint>, Optional<AutomationCommandError>)>&&) = 0;
};
static Ref<SimulatedInputDispatcher> create(WebPageProxy& page, SimulatedInputDispatcher::Client& client)
{
return adoptRef(*new SimulatedInputDispatcher(page, client));
}
~SimulatedInputDispatcher();
void run(Optional<WebCore::FrameIdentifier>, Vector<SimulatedInputKeyFrame>&& keyFrames, const HashMap<String, Ref<SimulatedInputSource>>& inputSources, AutomationCompletionHandler&&);
void cancel();
bool isActive() const;
private:
SimulatedInputDispatcher(WebPageProxy&, SimulatedInputDispatcher::Client&);
void transitionToNextKeyFrame();
void transitionBetweenKeyFrames(const SimulatedInputKeyFrame&, const SimulatedInputKeyFrame&, AutomationCompletionHandler&&);
void transitionToNextInputSourceState();
void transitionInputSourceToState(SimulatedInputSource&, SimulatedInputSourceState& newState, AutomationCompletionHandler&&);
void finishDispatching(Optional<AutomationCommandError>);
void keyFrameTransitionDurationTimerFired();
bool isKeyFrameTransitionComplete() const;
void resolveLocation(const WebCore::IntPoint& currentLocation, Optional<WebCore::IntPoint> location, MouseMoveOrigin, Optional<String> nodeHandle, Function<void (Optional<WebCore::IntPoint>, Optional<AutomationCommandError>)>&&);
WebPageProxy& m_page;
SimulatedInputDispatcher::Client& m_client;
Optional<WebCore::FrameIdentifier> m_frameID;
AutomationCompletionHandler m_runCompletionHandler;
AutomationCompletionHandler m_keyFrameTransitionCompletionHandler;
RunLoop::Timer<SimulatedInputDispatcher> m_keyFrameTransitionDurationTimer;
Vector<SimulatedInputKeyFrame> m_keyframes;
unsigned m_keyframeIndex { 0 };
unsigned m_inputSourceStateIndex { 0 };
};
}
#endif // ENABLE(WEBDRIVER_ACTIONS_API)