Index: components/test_runner/event_sender.cc |
diff --git a/components/test_runner/event_sender.cc b/components/test_runner/event_sender.cc |
deleted file mode 100644 |
index 01f8a5e9e7d593961184f118d51b18e0decd777a..0000000000000000000000000000000000000000 |
--- a/components/test_runner/event_sender.cc |
+++ /dev/null |
@@ -1,2909 +0,0 @@ |
-// Copyright 2014 The Chromium Authors. All rights reserved. |
-// Use of this source code is governed by a BSD-style license that can be |
-// found in the LICENSE file. |
- |
-#include "components/test_runner/event_sender.h" |
- |
-#include <stddef.h> |
- |
-#include <memory> |
- |
-#include "base/bind.h" |
-#include "base/bind_helpers.h" |
-#include "base/command_line.h" |
-#include "base/files/file_path.h" |
-#include "base/logging.h" |
-#include "base/macros.h" |
-#include "base/strings/string16.h" |
-#include "base/strings/string_util.h" |
-#include "base/strings/stringprintf.h" |
-#include "base/strings/utf_string_conversions.h" |
-#include "build/build_config.h" |
-#include "components/test_runner/mock_spell_check.h" |
-#include "components/test_runner/test_interfaces.h" |
-#include "components/test_runner/web_test_delegate.h" |
-#include "components/test_runner/web_view_test_proxy.h" |
-#include "components/test_runner/web_widget_test_proxy.h" |
-#include "gin/handle.h" |
-#include "gin/object_template_builder.h" |
-#include "gin/wrappable.h" |
-#include "net/base/filename_util.h" |
-#include "third_party/WebKit/public/platform/URLConversion.h" |
-#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" |
-#include "third_party/WebKit/public/platform/WebGestureEvent.h" |
-#include "third_party/WebKit/public/platform/WebKeyboardEvent.h" |
-#include "third_party/WebKit/public/platform/WebPointerProperties.h" |
-#include "third_party/WebKit/public/platform/WebString.h" |
-#include "third_party/WebKit/public/platform/WebTouchEvent.h" |
-#include "third_party/WebKit/public/platform/WebVector.h" |
-#include "third_party/WebKit/public/web/WebContextMenuData.h" |
-#include "third_party/WebKit/public/web/WebFrameWidget.h" |
-#include "third_party/WebKit/public/web/WebKit.h" |
-#include "third_party/WebKit/public/web/WebLocalFrame.h" |
-#include "third_party/WebKit/public/web/WebPagePopup.h" |
-#include "third_party/WebKit/public/web/WebView.h" |
-#include "ui/events/blink/blink_event_util.h" |
-#include "ui/events/keycodes/dom/keycode_converter.h" |
-#include "ui/events/keycodes/keyboard_codes.h" |
-#include "v8/include/v8.h" |
- |
-using blink::WebContextMenuData; |
-using blink::WebDragData; |
-using blink::WebDragOperationsMask; |
-using blink::WebFloatPoint; |
-using blink::WebGestureEvent; |
-using blink::WebInputEvent; |
-using blink::WebInputEventResult; |
-using blink::WebKeyboardEvent; |
-using blink::WebLocalFrame; |
-using blink::WebMenuItemInfo; |
-using blink::WebMouseEvent; |
-using blink::WebMouseWheelEvent; |
-using blink::WebPagePopup; |
-using blink::WebPoint; |
-using blink::WebPointerProperties; |
-using blink::WebString; |
-using blink::WebTouchEvent; |
-using blink::WebTouchPoint; |
-using blink::WebURL; |
-using blink::WebVector; |
-using blink::WebView; |
- |
-namespace test_runner { |
- |
-namespace { |
- |
-const int kRawMousePointerId = -1; |
-const char* const kPointerTypeStringUnknown = ""; |
-const char* const kPointerTypeStringMouse = "mouse"; |
-const char* const kPointerTypeStringTouch = "touch"; |
-const char* const kPointerTypeStringPen = "pen"; |
-const char* const kPointerTypeStringEraser = "eraser"; |
- |
-// Assigns |pointerType| from the provided |args|. Returns false if there was |
-// any error. |
-bool getPointerType(gin::Arguments* args, |
- bool isOnlyMouseAndPenAllowed, |
- WebPointerProperties::PointerType& pointerType) { |
- if (args->PeekNext().IsEmpty()) |
- return true; |
- std::string pointer_type_string; |
- if (!args->GetNext(&pointer_type_string)) { |
- args->ThrowError(); |
- return false; |
- } |
- if (isOnlyMouseAndPenAllowed && |
- (pointer_type_string == kPointerTypeStringUnknown || |
- pointer_type_string == kPointerTypeStringTouch)) { |
- args->ThrowError(); |
- return false; |
- } |
- if (pointer_type_string == kPointerTypeStringUnknown) { |
- pointerType = WebMouseEvent::PointerType::Unknown; |
- } else if (pointer_type_string == kPointerTypeStringMouse) { |
- pointerType = WebMouseEvent::PointerType::Mouse; |
- } else if (pointer_type_string == kPointerTypeStringTouch) { |
- pointerType = WebMouseEvent::PointerType::Touch; |
- } else if (pointer_type_string == kPointerTypeStringPen) { |
- pointerType = WebMouseEvent::PointerType::Pen; |
- } else if (pointer_type_string == kPointerTypeStringEraser) { |
- pointerType = WebMouseEvent::PointerType::Eraser; |
- } else { |
- args->ThrowError(); |
- return false; |
- } |
- return true; |
-} |
- |
-// Parses |pointerType|, |rawPointerId|, |pressure|, |tiltX| and |tiltY| from |
-// the provided |args|. Returns false if there was any error, assuming the last |
-// 3 of the five parsed parameters are optional. |
-bool getMousePenPointerProperties( |
- gin::Arguments* args, |
- WebPointerProperties::PointerType& pointerType, |
- int& rawPointerId, |
- float& pressure, |
- int& tiltX, |
- int& tiltY) { |
- pointerType = WebPointerProperties::PointerType::Mouse; |
- rawPointerId = kRawMousePointerId; |
- pressure = std::numeric_limits<float>::quiet_NaN(); |
- tiltX = 0; |
- tiltY = 0; |
- |
- // Only allow pen or mouse through this API. |
- if (!getPointerType(args, false, pointerType)) |
- return false; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&rawPointerId)) { |
- args->ThrowError(); |
- return false; |
- } |
- |
- // Parse optional params |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&pressure)) { |
- args->ThrowError(); |
- return false; |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&tiltX)) { |
- args->ThrowError(); |
- return false; |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&tiltY)) { |
- args->ThrowError(); |
- return false; |
- } |
- } |
- } |
- } |
- } |
- |
- return true; |
-} |
- |
-WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) { |
- switch (button_code) { |
- case -1: |
- return WebMouseEvent::Button::NoButton; |
- case 0: |
- return WebMouseEvent::Button::Left; |
- case 1: |
- return WebMouseEvent::Button::Middle; |
- case 2: |
- return WebMouseEvent::Button::Right; |
- } |
- NOTREACHED(); |
- return WebMouseEvent::Button::NoButton; |
-} |
- |
-int GetWebMouseEventModifierForButton(WebMouseEvent::Button button) { |
- switch (button) { |
- case WebMouseEvent::Button::NoButton: |
- return 0; |
- case WebMouseEvent::Button::Left: |
- return WebMouseEvent::LeftButtonDown; |
- case WebMouseEvent::Button::Middle: |
- return WebMouseEvent::MiddleButtonDown; |
- case WebMouseEvent::Button::Right: |
- return WebMouseEvent::RightButtonDown; |
- case WebPointerProperties::Button::X1: |
- case WebPointerProperties::Button::X2: |
- case WebPointerProperties::Button::Eraser: |
- return 0; // Not implemented yet |
- } |
- NOTREACHED(); |
- return 0; |
-} |
- |
-const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown |
- | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown; |
- |
-int modifiersWithButtons(int modifiers, int buttons) { |
- return (modifiers & ~kButtonsInModifiers) |
- | (buttons & kButtonsInModifiers); |
-} |
- |
-void InitMouseEventGeneric(WebMouseEvent::Button b, |
- int current_buttons, |
- const WebPoint& pos, |
- int click_count, |
- WebPointerProperties::PointerType pointerType, |
- int pointerId, |
- float pressure, |
- int tiltX, |
- int tiltY, |
- WebMouseEvent* e) { |
- e->button = b; |
- e->x = pos.x; |
- e->y = pos.y; |
- e->globalX = pos.x; |
- e->globalY = pos.y; |
- e->pointerType = pointerType; |
- e->id = pointerId; |
- e->force = pressure; |
- e->tiltX = tiltX; |
- e->tiltY = tiltY; |
- e->clickCount = click_count; |
-} |
- |
-void InitMouseEvent(WebMouseEvent::Button b, |
- int current_buttons, |
- const WebPoint& pos, |
- int click_count, |
- WebMouseEvent* e) { |
- InitMouseEventGeneric(b, current_buttons, pos, click_count, |
- WebPointerProperties::PointerType::Mouse, 0, 0.0, 0, 0, |
- e); |
-} |
- |
-void InitGestureEventFromMouseWheel(const WebMouseWheelEvent& wheel_event, |
- WebGestureEvent* gesture_event) { |
- gesture_event->sourceDevice = blink::WebGestureDeviceTouchpad; |
- gesture_event->x = wheel_event.x; |
- gesture_event->y = wheel_event.y; |
- gesture_event->globalX = wheel_event.globalX; |
- gesture_event->globalY = wheel_event.globalY; |
-} |
- |
-int GetKeyModifier(const std::string& modifier_name) { |
- const char* characters = modifier_name.c_str(); |
- if (!strcmp(characters, "ctrlKey") |
-#ifndef __APPLE__ |
- || !strcmp(characters, "addSelectionKey") |
-#endif |
- ) { |
- return WebInputEvent::ControlKey; |
- } else if (!strcmp(characters, "shiftKey") || |
- !strcmp(characters, "rangeSelectionKey")) { |
- return WebInputEvent::ShiftKey; |
- } else if (!strcmp(characters, "altKey")) { |
- return WebInputEvent::AltKey; |
-#ifdef __APPLE__ |
- } else if (!strcmp(characters, "metaKey") || |
- !strcmp(characters, "addSelectionKey")) { |
- return WebInputEvent::MetaKey; |
-#else |
- } else if (!strcmp(characters, "metaKey")) { |
- return WebInputEvent::MetaKey; |
-#endif |
- } else if (!strcmp(characters, "autoRepeat")) { |
- return WebInputEvent::IsAutoRepeat; |
- } else if (!strcmp(characters, "copyKey")) { |
-#ifdef __APPLE__ |
- return WebInputEvent::AltKey; |
-#else |
- return WebInputEvent::ControlKey; |
-#endif |
- } else if (!strcmp(characters, "accessKey")) { |
-#ifdef __APPLE__ |
- return WebInputEvent::AltKey | WebInputEvent::ControlKey; |
-#else |
- return WebInputEvent::AltKey; |
-#endif |
- } else if (!strcmp(characters, "leftButton")) { |
- return WebInputEvent::LeftButtonDown; |
- } else if (!strcmp(characters, "middleButton")) { |
- return WebInputEvent::MiddleButtonDown; |
- } else if (!strcmp(characters, "rightButton")) { |
- return WebInputEvent::RightButtonDown; |
- } else if (!strcmp(characters, "capsLockOn")) { |
- return WebInputEvent::CapsLockOn; |
- } else if (!strcmp(characters, "numLockOn")) { |
- return WebInputEvent::NumLockOn; |
- } else if (!strcmp(characters, "locationLeft")) { |
- return WebInputEvent::IsLeft; |
- } else if (!strcmp(characters, "locationRight")) { |
- return WebInputEvent::IsRight; |
- } else if (!strcmp(characters, "locationNumpad")) { |
- return WebInputEvent::IsKeyPad; |
- } else if (!strcmp(characters, "isComposing")) { |
- return WebInputEvent::IsComposing; |
- } else if (!strcmp(characters, "altGraphKey")) { |
- return WebInputEvent::AltGrKey; |
- } else if (!strcmp(characters, "fnKey")) { |
- return WebInputEvent::FnKey; |
- } else if (!strcmp(characters, "symbolKey")) { |
- return WebInputEvent::SymbolKey; |
- } else if (!strcmp(characters, "scrollLockOn")) { |
- return WebInputEvent::ScrollLockOn; |
- } |
- |
- return 0; |
-} |
- |
-int GetKeyModifiers(const std::vector<std::string>& modifier_names) { |
- int modifiers = 0; |
- for (std::vector<std::string>::const_iterator it = modifier_names.begin(); |
- it != modifier_names.end(); ++it) { |
- modifiers |= GetKeyModifier(*it); |
- } |
- return modifiers; |
-} |
- |
-int GetKeyModifiersFromV8(v8::Isolate* isolate, v8::Local<v8::Value> value) { |
- std::vector<std::string> modifier_names; |
- if (value->IsString()) { |
- modifier_names.push_back(gin::V8ToString(value)); |
- } else if (value->IsArray()) { |
- gin::Converter<std::vector<std::string> >::FromV8( |
- isolate, value, &modifier_names); |
- } |
- return GetKeyModifiers(modifier_names); |
-} |
- |
-WebMouseWheelEvent::Phase GetMouseWheelEventPhase( |
- const std::string& phase_name) { |
- if (phase_name == "phaseNone") { |
- return WebMouseWheelEvent::PhaseNone; |
- } else if (phase_name == "phaseBegan") { |
- return WebMouseWheelEvent::PhaseBegan; |
- } else if (phase_name == "phaseStationary") { |
- return WebMouseWheelEvent::PhaseStationary; |
- } else if (phase_name == "phaseChanged") { |
- return WebMouseWheelEvent::PhaseChanged; |
- } else if (phase_name == "phaseEnded") { |
- return WebMouseWheelEvent::PhaseEnded; |
- } else if (phase_name == "phaseCancelled") { |
- return WebMouseWheelEvent::PhaseCancelled; |
- } else if (phase_name == "phaseMayBegin") { |
- return WebMouseWheelEvent::PhaseMayBegin; |
- } |
- |
- return WebMouseWheelEvent::PhaseNone; |
-} |
- |
-WebMouseWheelEvent::Phase GetMouseWheelEventPhaseFromV8( |
- v8::Local<v8::Value> value) { |
- if (value->IsString()) |
- return GetMouseWheelEventPhase(gin::V8ToString(value)); |
- return WebMouseWheelEvent::PhaseNone; |
-} |
- |
-// Maximum distance (in space and time) for a mouse click to register as a |
-// double or triple click. |
-const double kMultipleClickTimeSec = 1; |
-const int kMultipleClickRadiusPixels = 5; |
-const char kSubMenuDepthIdentifier[] = "_"; |
-const char kSubMenuIdentifier[] = " >"; |
-const char kSeparatorIdentifier[] = "---------"; |
-const char kDisabledIdentifier[] = "#"; |
-const char kCheckedIdentifier[] = "*"; |
- |
-bool OutsideMultiClickRadius(const WebPoint& a, const WebPoint& b) { |
- return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) > |
- kMultipleClickRadiusPixels * kMultipleClickRadiusPixels; |
-} |
- |
-void PopulateCustomItems(const WebVector<WebMenuItemInfo>& customItems, |
- const std::string& prefix, std::vector<std::string>* strings) { |
- for (size_t i = 0; i < customItems.size(); ++i) { |
- std::string prefixCopy = prefix; |
- if (!customItems[i].enabled) |
- prefixCopy = kDisabledIdentifier + prefix; |
- if (customItems[i].checked) |
- prefixCopy = kCheckedIdentifier + prefix; |
- if (customItems[i].type == blink::WebMenuItemInfo::Separator) { |
- strings->push_back(prefixCopy + kSeparatorIdentifier); |
- } else if (customItems[i].type == blink::WebMenuItemInfo::SubMenu) { |
- strings->push_back(prefixCopy + customItems[i].label.utf8() + |
- customItems[i].icon.utf8() + kSubMenuIdentifier); |
- PopulateCustomItems(customItems[i].subMenuItems, prefixCopy + |
- kSubMenuDepthIdentifier, strings); |
- } else { |
- strings->push_back(prefixCopy + customItems[i].label.utf8() + |
- customItems[i].icon.utf8()); |
- } |
- } |
-} |
- |
-// Because actual context menu is implemented by the browser side, |
-// this function does only what LayoutTests are expecting: |
-// - Many test checks the count of items. So returning non-zero value makes |
-// sense. |
-// - Some test compares the count before and after some action. So changing the |
-// count based on flags also makes sense. This function is doing such for some |
-// flags. |
-// - Some test even checks actual string content. So providing it would be also |
-// helpful. |
-std::vector<std::string> MakeMenuItemStringsFor( |
- WebContextMenuData* context_menu, |
- WebTestDelegate* delegate) { |
- // These constants are based on Safari's context menu because tests are made |
- // for it. |
- static const char* kNonEditableMenuStrings[] = { |
- "Back", |
- "Reload Page", |
- "Open in Dashbaord", |
- "<separator>", |
- "View Source", |
- "Save Page As", |
- "Print Page", |
- "Inspect Element", |
- 0 |
- }; |
- static const char* kEditableMenuStrings[] = { |
- "Cut", |
- "Copy", |
- "<separator>", |
- "Paste", |
- "Spelling and Grammar", |
- "Substitutions, Transformations", |
- "Font", |
- "Speech", |
- "Paragraph Direction", |
- "<separator>", |
- 0 |
- }; |
- |
- // This is possible because mouse events are cancelleable. |
- if (!context_menu) |
- return std::vector<std::string>(); |
- |
- std::vector<std::string> strings; |
- |
- // Populate custom menu items if provided by blink. |
- PopulateCustomItems(context_menu->customItems, "", &strings); |
- |
- if (context_menu->isEditable) { |
- for (const char** item = kEditableMenuStrings; *item; ++item) { |
- strings.push_back(*item); |
- } |
- WebVector<WebString> suggestions; |
- MockSpellCheck::FillSuggestionList(context_menu->misspelledWord, |
- &suggestions); |
- for (size_t i = 0; i < suggestions.size(); ++i) { |
- strings.push_back(suggestions[i].utf8()); |
- } |
- } else { |
- for (const char** item = kNonEditableMenuStrings; *item; ++item) { |
- strings.push_back(*item); |
- } |
- } |
- |
- return strings; |
-} |
- |
-// How much we should scroll per event - the value here is chosen to match the |
-// WebKit impl and layout test results. |
-const float kScrollbarPixelsPerTick = 40.0f; |
- |
-// Get the edit command corresponding to a keyboard event. |
-// Returns true if the specified event corresponds to an edit command, the name |
-// of the edit command will be stored in |*name|. |
-bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) { |
-#if defined(OS_MACOSX) |
-// We only cares about Left,Right,Up,Down keys with Command or Command+Shift |
-// modifiers. These key events correspond to some special movement and |
-// selection editor commands. These keys will be marked as system key, which |
-// prevents them from being handled. Thus they must be handled specially. |
- if ((event.modifiers() & ~WebKeyboardEvent::ShiftKey) != |
- WebKeyboardEvent::MetaKey) |
- return false; |
- |
- switch (event.windowsKeyCode) { |
- case ui::VKEY_LEFT: |
- *name = "MoveToBeginningOfLine"; |
- break; |
- case ui::VKEY_RIGHT: |
- *name = "MoveToEndOfLine"; |
- break; |
- case ui::VKEY_UP: |
- *name = "MoveToBeginningOfDocument"; |
- break; |
- case ui::VKEY_DOWN: |
- *name = "MoveToEndOfDocument"; |
- break; |
- default: |
- return false; |
- } |
- |
- if (event.modifiers() & WebKeyboardEvent::ShiftKey) |
- name->append("AndModifySelection"); |
- |
- return true; |
-#else |
- return false; |
-#endif |
-} |
- |
-bool IsSystemKeyEvent(const WebKeyboardEvent& event) { |
-#if defined(OS_MACOSX) |
- return event.modifiers() & WebInputEvent::MetaKey && |
- event.windowsKeyCode != ui::VKEY_B && |
- event.windowsKeyCode != ui::VKEY_I; |
-#else |
- return !!(event.modifiers() & WebInputEvent::AltKey); |
-#endif |
-} |
- |
-bool GetScrollUnits(gin::Arguments* args, WebGestureEvent::ScrollUnits* units) { |
- std::string units_string; |
- if (!args->PeekNext().IsEmpty()) { |
- if (args->PeekNext()->IsString()) |
- args->GetNext(&units_string); |
- if (units_string == "Page") { |
- *units = WebGestureEvent::Page; |
- return true; |
- } else if (units_string == "Pixels") { |
- *units = WebGestureEvent::Pixels; |
- return true; |
- } else if (units_string == "PrecisePixels") { |
- *units = WebGestureEvent::PrecisePixels; |
- return true; |
- } else { |
- args->ThrowError(); |
- return false; |
- } |
- } else { |
- *units = WebGestureEvent::PrecisePixels; |
- return true; |
- } |
-} |
- |
-const char* kSourceDeviceStringTouchpad = "touchpad"; |
-const char* kSourceDeviceStringTouchscreen = "touchscreen"; |
- |
-} // namespace |
- |
-class EventSenderBindings : public gin::Wrappable<EventSenderBindings> { |
- public: |
- static gin::WrapperInfo kWrapperInfo; |
- |
- static void Install(base::WeakPtr<EventSender> sender, |
- blink::WebLocalFrame* frame); |
- |
- private: |
- explicit EventSenderBindings(base::WeakPtr<EventSender> sender); |
- ~EventSenderBindings() override; |
- |
- // gin::Wrappable: |
- gin::ObjectTemplateBuilder GetObjectTemplateBuilder( |
- v8::Isolate* isolate) override; |
- |
- // Bound methods: |
- void EnableDOMUIEventLogging(); |
- void FireKeyboardEventsToElement(); |
- void ClearKillRing(); |
- std::vector<std::string> ContextClick(); |
- void TextZoomIn(); |
- void TextZoomOut(); |
- void ZoomPageIn(); |
- void ZoomPageOut(); |
- void SetPageZoomFactor(double factor); |
- void ClearTouchPoints(); |
- void ReleaseTouchPoint(unsigned index); |
- void UpdateTouchPoint(unsigned index, |
- double x, |
- double y, |
- gin::Arguments* args); |
- void CancelTouchPoint(unsigned index); |
- void SetTouchModifier(const std::string& key_name, bool set_mask); |
- void SetTouchCancelable(bool cancelable); |
- void DumpFilenameBeingDragged(); |
- void GestureFlingCancel(); |
- void GestureFlingStart(float x, |
- float y, |
- float velocity_x, |
- float velocity_y, |
- gin::Arguments* args); |
- bool IsFlinging() const; |
- void GestureScrollFirstPoint(int x, int y); |
- void TouchStart(gin::Arguments* args); |
- void TouchMove(gin::Arguments* args); |
- void TouchCancel(gin::Arguments* args); |
- void TouchEnd(gin::Arguments* args); |
- void NotifyStartOfTouchScroll(); |
- void LeapForward(int milliseconds); |
- double LastEventTimestamp(); |
- void BeginDragWithFiles(const std::vector<std::string>& files); |
- void AddTouchPoint(double x, double y, gin::Arguments* args); |
- void GestureScrollBegin(gin::Arguments* args); |
- void GestureScrollEnd(gin::Arguments* args); |
- void GestureScrollUpdate(gin::Arguments* args); |
- void GesturePinchBegin(gin::Arguments* args); |
- void GesturePinchEnd(gin::Arguments* args); |
- void GesturePinchUpdate(gin::Arguments* args); |
- void GestureTap(gin::Arguments* args); |
- void GestureTapDown(gin::Arguments* args); |
- void GestureShowPress(gin::Arguments* args); |
- void GestureTapCancel(gin::Arguments* args); |
- void GestureLongPress(gin::Arguments* args); |
- void GestureLongTap(gin::Arguments* args); |
- void GestureTwoFingerTap(gin::Arguments* args); |
- void ContinuousMouseScrollBy(gin::Arguments* args); |
- void MouseMoveTo(gin::Arguments* args); |
- void MouseLeave(); |
- void MouseScrollBy(gin::Arguments* args); |
- void ScheduleAsynchronousClick(gin::Arguments* args); |
- void ScheduleAsynchronousKeyDown(gin::Arguments* args); |
- void MouseDown(gin::Arguments* args); |
- void MouseUp(gin::Arguments* args); |
- void SetMouseButtonState(gin::Arguments* args); |
- void KeyDown(gin::Arguments* args); |
- |
- // Binding properties: |
- bool ForceLayoutOnEvents() const; |
- void SetForceLayoutOnEvents(bool force); |
- bool IsDragMode() const; |
- void SetIsDragMode(bool drag_mode); |
- |
-#if defined(OS_WIN) |
- int WmKeyDown() const; |
- void SetWmKeyDown(int key_down); |
- |
- int WmKeyUp() const; |
- void SetWmKeyUp(int key_up); |
- |
- int WmChar() const; |
- void SetWmChar(int wm_char); |
- |
- int WmDeadChar() const; |
- void SetWmDeadChar(int dead_char); |
- |
- int WmSysKeyDown() const; |
- void SetWmSysKeyDown(int key_down); |
- |
- int WmSysKeyUp() const; |
- void SetWmSysKeyUp(int key_up); |
- |
- int WmSysChar() const; |
- void SetWmSysChar(int sys_char); |
- |
- int WmSysDeadChar() const; |
- void SetWmSysDeadChar(int sys_dead_char); |
-#endif |
- |
- base::WeakPtr<EventSender> sender_; |
- |
- DISALLOW_COPY_AND_ASSIGN(EventSenderBindings); |
-}; |
- |
-gin::WrapperInfo EventSenderBindings::kWrapperInfo = {gin::kEmbedderNativeGin}; |
- |
-EventSenderBindings::EventSenderBindings(base::WeakPtr<EventSender> sender) |
- : sender_(sender) { |
-} |
- |
-EventSenderBindings::~EventSenderBindings() {} |
- |
-// static |
-void EventSenderBindings::Install(base::WeakPtr<EventSender> sender, |
- WebLocalFrame* frame) { |
- v8::Isolate* isolate = blink::mainThreadIsolate(); |
- v8::HandleScope handle_scope(isolate); |
- v8::Local<v8::Context> context = frame->mainWorldScriptContext(); |
- if (context.IsEmpty()) |
- return; |
- |
- v8::Context::Scope context_scope(context); |
- |
- gin::Handle<EventSenderBindings> bindings = |
- gin::CreateHandle(isolate, new EventSenderBindings(sender)); |
- if (bindings.IsEmpty()) |
- return; |
- v8::Local<v8::Object> global = context->Global(); |
- global->Set(gin::StringToV8(isolate, "eventSender"), bindings.ToV8()); |
-} |
- |
-gin::ObjectTemplateBuilder |
-EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) { |
- return gin::Wrappable<EventSenderBindings>::GetObjectTemplateBuilder(isolate) |
- .SetMethod("enableDOMUIEventLogging", |
- &EventSenderBindings::EnableDOMUIEventLogging) |
- .SetMethod("fireKeyboardEventsToElement", |
- &EventSenderBindings::FireKeyboardEventsToElement) |
- .SetMethod("clearKillRing", &EventSenderBindings::ClearKillRing) |
- .SetMethod("contextClick", &EventSenderBindings::ContextClick) |
- .SetMethod("textZoomIn", &EventSenderBindings::TextZoomIn) |
- .SetMethod("textZoomOut", &EventSenderBindings::TextZoomOut) |
- .SetMethod("zoomPageIn", &EventSenderBindings::ZoomPageIn) |
- .SetMethod("zoomPageOut", &EventSenderBindings::ZoomPageOut) |
- .SetMethod("setPageZoomFactor", &EventSenderBindings::SetPageZoomFactor) |
- .SetMethod("clearTouchPoints", &EventSenderBindings::ClearTouchPoints) |
- .SetMethod("releaseTouchPoint", &EventSenderBindings::ReleaseTouchPoint) |
- .SetMethod("updateTouchPoint", &EventSenderBindings::UpdateTouchPoint) |
- .SetMethod("cancelTouchPoint", &EventSenderBindings::CancelTouchPoint) |
- .SetMethod("setTouchModifier", &EventSenderBindings::SetTouchModifier) |
- .SetMethod("setTouchCancelable", &EventSenderBindings::SetTouchCancelable) |
- .SetMethod("dumpFilenameBeingDragged", |
- &EventSenderBindings::DumpFilenameBeingDragged) |
- .SetMethod("gestureFlingCancel", &EventSenderBindings::GestureFlingCancel) |
- .SetMethod("gestureFlingStart", &EventSenderBindings::GestureFlingStart) |
- .SetMethod("isFlinging", &EventSenderBindings::IsFlinging) |
- .SetMethod("gestureScrollFirstPoint", |
- &EventSenderBindings::GestureScrollFirstPoint) |
- .SetMethod("touchStart", &EventSenderBindings::TouchStart) |
- .SetMethod("touchMove", &EventSenderBindings::TouchMove) |
- .SetMethod("touchCancel", &EventSenderBindings::TouchCancel) |
- .SetMethod("touchEnd", &EventSenderBindings::TouchEnd) |
- .SetMethod("notifyStartOfTouchScroll", |
- &EventSenderBindings::NotifyStartOfTouchScroll) |
- .SetMethod("leapForward", &EventSenderBindings::LeapForward) |
- .SetMethod("lastEventTimestamp", &EventSenderBindings::LastEventTimestamp) |
- .SetMethod("beginDragWithFiles", &EventSenderBindings::BeginDragWithFiles) |
- .SetMethod("addTouchPoint", &EventSenderBindings::AddTouchPoint) |
- .SetMethod("gestureScrollBegin", &EventSenderBindings::GestureScrollBegin) |
- .SetMethod("gestureScrollEnd", &EventSenderBindings::GestureScrollEnd) |
- .SetMethod("gestureScrollUpdate", |
- &EventSenderBindings::GestureScrollUpdate) |
- .SetMethod("gesturePinchBegin", &EventSenderBindings::GesturePinchBegin) |
- .SetMethod("gesturePinchEnd", &EventSenderBindings::GesturePinchEnd) |
- .SetMethod("gesturePinchUpdate", &EventSenderBindings::GesturePinchUpdate) |
- .SetMethod("gestureTap", &EventSenderBindings::GestureTap) |
- .SetMethod("gestureTapDown", &EventSenderBindings::GestureTapDown) |
- .SetMethod("gestureShowPress", &EventSenderBindings::GestureShowPress) |
- .SetMethod("gestureTapCancel", &EventSenderBindings::GestureTapCancel) |
- .SetMethod("gestureLongPress", &EventSenderBindings::GestureLongPress) |
- .SetMethod("gestureLongTap", &EventSenderBindings::GestureLongTap) |
- .SetMethod("gestureTwoFingerTap", |
- &EventSenderBindings::GestureTwoFingerTap) |
- .SetMethod("continuousMouseScrollBy", |
- &EventSenderBindings::ContinuousMouseScrollBy) |
- .SetMethod("keyDown", &EventSenderBindings::KeyDown) |
- .SetMethod("mouseDown", &EventSenderBindings::MouseDown) |
- .SetMethod("mouseMoveTo", &EventSenderBindings::MouseMoveTo) |
- .SetMethod("mouseLeave", &EventSenderBindings::MouseLeave) |
- .SetMethod("mouseScrollBy", &EventSenderBindings::MouseScrollBy) |
- .SetMethod("mouseUp", &EventSenderBindings::MouseUp) |
- .SetMethod("setMouseButtonState", |
- &EventSenderBindings::SetMouseButtonState) |
- .SetMethod("scheduleAsynchronousClick", |
- &EventSenderBindings::ScheduleAsynchronousClick) |
- .SetMethod("scheduleAsynchronousKeyDown", |
- &EventSenderBindings::ScheduleAsynchronousKeyDown) |
- .SetProperty("forceLayoutOnEvents", |
- &EventSenderBindings::ForceLayoutOnEvents, |
- &EventSenderBindings::SetForceLayoutOnEvents) |
-#if defined(OS_WIN) |
- .SetProperty("WM_KEYDOWN", &EventSenderBindings::WmKeyDown, |
- &EventSenderBindings::SetWmKeyDown) |
- .SetProperty("WM_KEYUP", &EventSenderBindings::WmKeyUp, |
- &EventSenderBindings::SetWmKeyUp) |
- .SetProperty("WM_CHAR", &EventSenderBindings::WmChar, |
- &EventSenderBindings::SetWmChar) |
- .SetProperty("WM_DEADCHAR", &EventSenderBindings::WmDeadChar, |
- &EventSenderBindings::SetWmDeadChar) |
- .SetProperty("WM_SYSKEYDOWN", &EventSenderBindings::WmSysKeyDown, |
- &EventSenderBindings::SetWmSysKeyDown) |
- .SetProperty("WM_SYSKEYUP", &EventSenderBindings::WmSysKeyUp, |
- &EventSenderBindings::SetWmSysKeyUp) |
- .SetProperty("WM_SYSCHAR", &EventSenderBindings::WmSysChar, |
- &EventSenderBindings::SetWmSysChar) |
- .SetProperty("WM_SYSDEADCHAR", &EventSenderBindings::WmSysDeadChar, |
- &EventSenderBindings::SetWmSysDeadChar) |
-#endif |
- .SetProperty("dragMode", &EventSenderBindings::IsDragMode, |
- &EventSenderBindings::SetIsDragMode); |
-} |
- |
-void EventSenderBindings::EnableDOMUIEventLogging() { |
- if (sender_) |
- sender_->EnableDOMUIEventLogging(); |
-} |
- |
-void EventSenderBindings::FireKeyboardEventsToElement() { |
- if (sender_) |
- sender_->FireKeyboardEventsToElement(); |
-} |
- |
-void EventSenderBindings::ClearKillRing() { |
- if (sender_) |
- sender_->ClearKillRing(); |
-} |
- |
-std::vector<std::string> EventSenderBindings::ContextClick() { |
- if (sender_) |
- return sender_->ContextClick(); |
- return std::vector<std::string>(); |
-} |
- |
-void EventSenderBindings::TextZoomIn() { |
- if (sender_) |
- sender_->TextZoomIn(); |
-} |
- |
-void EventSenderBindings::TextZoomOut() { |
- if (sender_) |
- sender_->TextZoomOut(); |
-} |
- |
-void EventSenderBindings::ZoomPageIn() { |
- if (sender_) |
- sender_->ZoomPageIn(); |
-} |
- |
-void EventSenderBindings::ZoomPageOut() { |
- if (sender_) |
- sender_->ZoomPageOut(); |
-} |
- |
-void EventSenderBindings::SetPageZoomFactor(double factor) { |
- if (sender_) |
- sender_->SetPageZoomFactor(factor); |
-} |
- |
-void EventSenderBindings::ClearTouchPoints() { |
- if (sender_) |
- sender_->ClearTouchPoints(); |
-} |
- |
-void EventSenderBindings::ReleaseTouchPoint(unsigned index) { |
- if (sender_) |
- sender_->ReleaseTouchPoint(index); |
-} |
- |
-void EventSenderBindings::UpdateTouchPoint(unsigned index, |
- double x, |
- double y, |
- gin::Arguments* args) { |
- if (sender_) { |
- sender_->UpdateTouchPoint(index, static_cast<float>(x), |
- static_cast<float>(y), args); |
- } |
-} |
- |
-void EventSenderBindings::CancelTouchPoint(unsigned index) { |
- if (sender_) |
- sender_->CancelTouchPoint(index); |
-} |
- |
-void EventSenderBindings::SetTouchModifier(const std::string& key_name, |
- bool set_mask) { |
- if (sender_) |
- sender_->SetTouchModifier(key_name, set_mask); |
-} |
- |
-void EventSenderBindings::SetTouchCancelable(bool cancelable) { |
- if (sender_) |
- sender_->SetTouchCancelable(cancelable); |
-} |
- |
-void EventSenderBindings::DumpFilenameBeingDragged() { |
- if (sender_) |
- sender_->DumpFilenameBeingDragged(); |
-} |
- |
-void EventSenderBindings::GestureFlingCancel() { |
- if (sender_) |
- sender_->GestureFlingCancel(); |
-} |
- |
-void EventSenderBindings::GestureFlingStart(float x, |
- float y, |
- float velocity_x, |
- float velocity_y, |
- gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureFlingStart(x, y, velocity_x, velocity_y, args); |
-} |
- |
-bool EventSenderBindings::IsFlinging() const { |
- if (sender_) |
- return sender_->IsFlinging(); |
- return false; |
-} |
- |
-void EventSenderBindings::GestureScrollFirstPoint(int x, int y) { |
- if (sender_) |
- sender_->GestureScrollFirstPoint(x, y); |
-} |
- |
-void EventSenderBindings::TouchStart(gin::Arguments* args) { |
- if (sender_) |
- sender_->TouchStart(args); |
-} |
- |
-void EventSenderBindings::TouchMove(gin::Arguments* args) { |
- if (sender_) |
- sender_->TouchMove(args); |
-} |
- |
-void EventSenderBindings::TouchCancel(gin::Arguments* args) { |
- if (sender_) |
- sender_->TouchCancel(args); |
-} |
- |
-void EventSenderBindings::TouchEnd(gin::Arguments* args) { |
- if (sender_) |
- sender_->TouchEnd(args); |
-} |
- |
-void EventSenderBindings::NotifyStartOfTouchScroll() { |
- if (sender_) |
- sender_->NotifyStartOfTouchScroll(); |
-} |
- |
-void EventSenderBindings::LeapForward(int milliseconds) { |
- if (sender_) |
- sender_->LeapForward(milliseconds); |
-} |
- |
-double EventSenderBindings::LastEventTimestamp() { |
- if (sender_) |
- return sender_->last_event_timestamp(); |
- return 0; |
-} |
- |
-void EventSenderBindings::BeginDragWithFiles( |
- const std::vector<std::string>& files) { |
- if (sender_) |
- sender_->BeginDragWithFiles(files); |
-} |
- |
-void EventSenderBindings::AddTouchPoint(double x, |
- double y, |
- gin::Arguments* args) { |
- if (sender_) |
- sender_->AddTouchPoint(static_cast<float>(x), static_cast<float>(y), args); |
-} |
- |
-void EventSenderBindings::GestureScrollBegin(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureScrollBegin(args); |
-} |
- |
-void EventSenderBindings::GestureScrollEnd(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureScrollEnd(args); |
-} |
- |
-void EventSenderBindings::GestureScrollUpdate(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureScrollUpdate(args); |
-} |
- |
-void EventSenderBindings::GesturePinchBegin(gin::Arguments* args) { |
- if (sender_) |
- sender_->GesturePinchBegin(args); |
-} |
- |
-void EventSenderBindings::GesturePinchEnd(gin::Arguments* args) { |
- if (sender_) |
- sender_->GesturePinchEnd(args); |
-} |
- |
-void EventSenderBindings::GesturePinchUpdate(gin::Arguments* args) { |
- if (sender_) |
- sender_->GesturePinchUpdate(args); |
-} |
- |
-void EventSenderBindings::GestureTap(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureTap(args); |
-} |
- |
-void EventSenderBindings::GestureTapDown(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureTapDown(args); |
-} |
- |
-void EventSenderBindings::GestureShowPress(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureShowPress(args); |
-} |
- |
-void EventSenderBindings::GestureTapCancel(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureTapCancel(args); |
-} |
- |
-void EventSenderBindings::GestureLongPress(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureLongPress(args); |
-} |
- |
-void EventSenderBindings::GestureLongTap(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureLongTap(args); |
-} |
- |
-void EventSenderBindings::GestureTwoFingerTap(gin::Arguments* args) { |
- if (sender_) |
- sender_->GestureTwoFingerTap(args); |
-} |
- |
-void EventSenderBindings::ContinuousMouseScrollBy(gin::Arguments* args) { |
- if (sender_) |
- sender_->MouseScrollBy(args, EventSender::MouseScrollType::PIXEL); |
-} |
- |
-void EventSenderBindings::MouseMoveTo(gin::Arguments* args) { |
- if (sender_) |
- sender_->MouseMoveTo(args); |
-} |
- |
-void EventSenderBindings::MouseLeave() { |
- if (sender_) |
- sender_->MouseLeave(); |
-} |
- |
-void EventSenderBindings::MouseScrollBy(gin::Arguments* args) { |
- if (sender_) |
- sender_->MouseScrollBy(args, EventSender::MouseScrollType::TICK); |
-} |
- |
-void EventSenderBindings::ScheduleAsynchronousClick(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- int button_number = 0; |
- int modifiers = 0; |
- if (!args->PeekNext().IsEmpty()) { |
- args->GetNext(&button_number); |
- if (!args->PeekNext().IsEmpty()) |
- modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext()); |
- } |
- sender_->ScheduleAsynchronousClick(button_number, modifiers); |
-} |
- |
-void EventSenderBindings::ScheduleAsynchronousKeyDown(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- std::string code_str; |
- int modifiers = 0; |
- int location = DOMKeyLocationStandard; |
- args->GetNext(&code_str); |
- if (!args->PeekNext().IsEmpty()) { |
- v8::Local<v8::Value> value; |
- args->GetNext(&value); |
- modifiers = GetKeyModifiersFromV8(args->isolate(), value); |
- if (!args->PeekNext().IsEmpty()) |
- args->GetNext(&location); |
- } |
- sender_->ScheduleAsynchronousKeyDown(code_str, modifiers, |
- static_cast<KeyLocationCode>(location)); |
-} |
- |
-void EventSenderBindings::MouseDown(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- int button_number = 0; |
- int modifiers = 0; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&button_number)) { |
- args->ThrowError(); |
- return; |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext()); |
- args->Skip(); |
- } |
- } |
- |
- WebPointerProperties::PointerType pointerType = |
- WebPointerProperties::PointerType::Mouse; |
- int pointerId = 0; |
- float pressure = 0; |
- int tiltX = 0; |
- int tiltY = 0; |
- if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure, |
- tiltX, tiltY)) |
- return; |
- |
- sender_->PointerDown(button_number, modifiers, pointerType, pointerId, |
- pressure, tiltX, tiltY); |
-} |
- |
-void EventSenderBindings::MouseUp(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- int button_number = 0; |
- int modifiers = 0; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&button_number)) { |
- args->ThrowError(); |
- return; |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext()); |
- args->Skip(); |
- } |
- } |
- |
- WebPointerProperties::PointerType pointerType = |
- WebPointerProperties::PointerType::Mouse; |
- int pointerId = 0; |
- float pressure = 0; |
- int tiltX = 0; |
- int tiltY = 0; |
- if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure, |
- tiltX, tiltY)) |
- return; |
- |
- sender_->PointerUp(button_number, modifiers, pointerType, pointerId, pressure, |
- tiltX, tiltY); |
-} |
- |
-void EventSenderBindings::SetMouseButtonState(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- int button_number; |
- if (!args->GetNext(&button_number)) { |
- args->ThrowError(); |
- return; |
- } |
- |
- int modifiers = -1; // Default to the modifier implied by button_number |
- if (!args->PeekNext().IsEmpty()) { |
- modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext()); |
- } |
- |
- sender_->SetMouseButtonState(button_number, modifiers); |
-} |
- |
-void EventSenderBindings::KeyDown(gin::Arguments* args) { |
- if (!sender_) |
- return; |
- |
- std::string code_str; |
- int modifiers = 0; |
- int location = DOMKeyLocationStandard; |
- args->GetNext(&code_str); |
- if (!args->PeekNext().IsEmpty()) { |
- v8::Local<v8::Value> value; |
- args->GetNext(&value); |
- modifiers = GetKeyModifiersFromV8(args->isolate(), value); |
- if (!args->PeekNext().IsEmpty()) |
- args->GetNext(&location); |
- } |
- sender_->KeyDown(code_str, modifiers, static_cast<KeyLocationCode>(location)); |
-} |
- |
-bool EventSenderBindings::ForceLayoutOnEvents() const { |
- if (sender_) |
- return sender_->force_layout_on_events(); |
- return false; |
-} |
- |
-void EventSenderBindings::SetForceLayoutOnEvents(bool force) { |
- if (sender_) |
- sender_->set_force_layout_on_events(force); |
-} |
- |
-bool EventSenderBindings::IsDragMode() const { |
- if (sender_) |
- return sender_->is_drag_mode(); |
- return true; |
-} |
- |
-void EventSenderBindings::SetIsDragMode(bool drag_mode) { |
- if (sender_) |
- sender_->set_is_drag_mode(drag_mode); |
-} |
- |
-#if defined(OS_WIN) |
-int EventSenderBindings::WmKeyDown() const { |
- if (sender_) |
- return sender_->wm_key_down(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmKeyDown(int key_down) { |
- if (sender_) |
- sender_->set_wm_key_down(key_down); |
-} |
- |
-int EventSenderBindings::WmKeyUp() const { |
- if (sender_) |
- return sender_->wm_key_up(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmKeyUp(int key_up) { |
- if (sender_) |
- sender_->set_wm_key_up(key_up); |
-} |
- |
-int EventSenderBindings::WmChar() const { |
- if (sender_) |
- return sender_->wm_char(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmChar(int wm_char) { |
- if (sender_) |
- sender_->set_wm_char(wm_char); |
-} |
- |
-int EventSenderBindings::WmDeadChar() const { |
- if (sender_) |
- return sender_->wm_dead_char(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmDeadChar(int dead_char) { |
- if (sender_) |
- sender_->set_wm_dead_char(dead_char); |
-} |
- |
-int EventSenderBindings::WmSysKeyDown() const { |
- if (sender_) |
- return sender_->wm_sys_key_down(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmSysKeyDown(int key_down) { |
- if (sender_) |
- sender_->set_wm_sys_key_down(key_down); |
-} |
- |
-int EventSenderBindings::WmSysKeyUp() const { |
- if (sender_) |
- return sender_->wm_sys_key_up(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmSysKeyUp(int key_up) { |
- if (sender_) |
- sender_->set_wm_sys_key_up(key_up); |
-} |
- |
-int EventSenderBindings::WmSysChar() const { |
- if (sender_) |
- return sender_->wm_sys_char(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmSysChar(int sys_char) { |
- if (sender_) |
- sender_->set_wm_sys_char(sys_char); |
-} |
- |
-int EventSenderBindings::WmSysDeadChar() const { |
- if (sender_) |
- return sender_->wm_sys_dead_char(); |
- return 0; |
-} |
- |
-void EventSenderBindings::SetWmSysDeadChar(int sys_dead_char) { |
- if (sender_) |
- sender_->set_wm_sys_dead_char(sys_dead_char); |
-} |
-#endif |
- |
-// EventSender ----------------------------------------------------------------- |
- |
-WebMouseEvent::Button EventSender::last_button_type_ = |
- WebMouseEvent::Button::NoButton; |
- |
-EventSender::SavedEvent::SavedEvent() |
- : type(TYPE_UNSPECIFIED), |
- button_type(WebMouseEvent::Button::NoButton), |
- milliseconds(0), |
- modifiers(0) {} |
- |
-EventSender::EventSender(WebWidgetTestProxyBase* web_widget_test_proxy_base) |
- : web_widget_test_proxy_base_(web_widget_test_proxy_base), |
- replaying_saved_events_(false), |
- weak_factory_(this) { |
- Reset(); |
-} |
- |
-EventSender::~EventSender() {} |
- |
-void EventSender::Reset() { |
- DCHECK(current_drag_data_.isNull()); |
- current_drag_data_.reset(); |
- current_drag_effect_ = blink::WebDragOperationNone; |
- current_drag_effects_allowed_ = blink::WebDragOperationNone; |
- if (widget() && |
- current_pointer_state_[kRawMousePointerId].pressed_button_ != |
- WebMouseEvent::Button::NoButton) |
- widget()->mouseCaptureLost(); |
- current_pointer_state_.clear(); |
- is_drag_mode_ = true; |
- force_layout_on_events_ = true; |
- |
-#if defined(OS_WIN) |
- wm_key_down_ = WM_KEYDOWN; |
- wm_key_up_ = WM_KEYUP; |
- wm_char_ = WM_CHAR; |
- wm_dead_char_ = WM_DEADCHAR; |
- wm_sys_key_down_ = WM_SYSKEYDOWN; |
- wm_sys_key_up_ = WM_SYSKEYUP; |
- wm_sys_char_ = WM_SYSCHAR; |
- wm_sys_dead_char_ = WM_SYSDEADCHAR; |
-#endif |
- |
- last_click_time_sec_ = 0; |
- last_click_pos_ = WebPoint(0, 0); |
- last_button_type_ = WebMouseEvent::Button::NoButton; |
- touch_points_.clear(); |
- last_context_menu_data_.reset(); |
- weak_factory_.InvalidateWeakPtrs(); |
- current_gesture_location_ = WebPoint(0, 0); |
- mouse_event_queue_.clear(); |
- |
- time_offset_ms_ = 0; |
- click_count_ = 0; |
- |
- touch_modifiers_ = 0; |
- touch_cancelable_ = true; |
- touch_points_.clear(); |
-} |
- |
-void EventSender::Install(WebLocalFrame* frame) { |
- EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame); |
-} |
- |
-void EventSender::SetContextMenuData(const WebContextMenuData& data) { |
- last_context_menu_data_.reset(new WebContextMenuData(data)); |
-} |
- |
-int EventSender::ModifiersForPointer(int pointer_id) { |
- return modifiersWithButtons( |
- current_pointer_state_[pointer_id].modifiers_, |
- current_pointer_state_[pointer_id].current_buttons_); |
-} |
- |
-void EventSender::DoDragDrop(const WebDragData& drag_data, |
- WebDragOperationsMask mask) { |
- WebMouseEvent raw_event(WebInputEvent::MouseDown, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &raw_event); |
- |
- std::unique_ptr<WebInputEvent> widget_event = |
- TransformScreenToWidgetCoordinates(raw_event); |
- const WebMouseEvent* event = |
- widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get()) |
- : &raw_event; |
- |
- WebPoint client_point(event->x, event->y); |
- WebPoint screen_point(event->globalX, event->globalY); |
- current_drag_data_ = drag_data; |
- current_drag_effects_allowed_ = mask; |
- current_drag_effect_ = mainFrameWidget()->dragTargetDragEnter( |
- drag_data, client_point, screen_point, current_drag_effects_allowed_, |
- modifiersWithButtons( |
- current_pointer_state_[kRawMousePointerId].modifiers_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_)); |
- |
- // Finish processing events. |
- ReplaySavedEvents(); |
-} |
- |
-void EventSender::MouseDown(int button_number, int modifiers) { |
- PointerDown(button_number, modifiers, |
- WebPointerProperties::PointerType::Mouse, kRawMousePointerId, 0.0, |
- 0, 0); |
-} |
- |
-void EventSender::MouseUp(int button_number, int modifiers) { |
- PointerUp(button_number, modifiers, WebPointerProperties::PointerType::Mouse, |
- kRawMousePointerId, 0.0, 0, 0); |
-} |
- |
-void EventSender::PointerDown(int button_number, |
- int modifiers, |
- WebPointerProperties::PointerType pointerType, |
- int pointerId, |
- float pressure, |
- int tiltX, |
- int tiltY) { |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- DCHECK_NE(-1, button_number); |
- |
- WebMouseEvent::Button button_type = |
- GetButtonTypeFromButtonNumber(button_number); |
- |
- int click_count = 0; |
- current_pointer_state_[pointerId].pressed_button_ = button_type; |
- current_pointer_state_[pointerId].current_buttons_ |= |
- GetWebMouseEventModifierForButton(button_type); |
- current_pointer_state_[pointerId].modifiers_ = modifiers; |
- |
- if (pointerType == WebPointerProperties::PointerType::Mouse) { |
- UpdateClickCountForButton(button_type); |
- click_count = click_count_; |
- } |
- WebMouseEvent event(WebInputEvent::MouseDown, ModifiersForPointer(pointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEventGeneric(current_pointer_state_[pointerId].pressed_button_, |
- current_pointer_state_[pointerId].current_buttons_, |
- current_pointer_state_[pointerId].last_pos_, |
- click_count, pointerType, pointerId, pressure, tiltX, |
- tiltY, &event); |
- |
- HandleInputEventOnViewOrPopup(event); |
-} |
- |
-void EventSender::PointerUp(int button_number, |
- int modifiers, |
- WebPointerProperties::PointerType pointerType, |
- int pointerId, |
- float pressure, |
- int tiltX, |
- int tiltY) { |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- DCHECK_NE(-1, button_number); |
- |
- WebMouseEvent::Button button_type = |
- GetButtonTypeFromButtonNumber(button_number); |
- |
- if (pointerType == WebPointerProperties::PointerType::Mouse && |
- is_drag_mode_ && !replaying_saved_events_) { |
- SavedEvent saved_event; |
- saved_event.type = SavedEvent::TYPE_MOUSE_UP; |
- saved_event.button_type = button_type; |
- saved_event.modifiers = modifiers; |
- mouse_event_queue_.push_back(saved_event); |
- ReplaySavedEvents(); |
- } else { |
- current_pointer_state_[pointerId].modifiers_ = modifiers; |
- current_pointer_state_[pointerId].current_buttons_ &= |
- ~GetWebMouseEventModifierForButton(button_type); |
- current_pointer_state_[pointerId].pressed_button_ = |
- WebMouseEvent::Button::NoButton; |
- |
- WebMouseEvent event(WebInputEvent::MouseUp, ModifiersForPointer(pointerId), |
- GetCurrentEventTimeSec()); |
- int click_count = pointerType == WebPointerProperties::PointerType::Mouse |
- ? click_count_ |
- : 0; |
- InitMouseEventGeneric( |
- button_type, current_pointer_state_[pointerId].current_buttons_, |
- current_pointer_state_[pointerId].last_pos_, click_count, pointerType, |
- pointerId, pressure, tiltX, tiltY, &event); |
- HandleInputEventOnViewOrPopup(event); |
- if (pointerType == WebPointerProperties::PointerType::Mouse) |
- DoDragAfterMouseUp(event); |
- } |
-} |
- |
-void EventSender::SetMouseButtonState(int button_number, int modifiers) { |
- current_pointer_state_[kRawMousePointerId].pressed_button_ = |
- GetButtonTypeFromButtonNumber(button_number); |
- current_pointer_state_[kRawMousePointerId].current_buttons_ = |
- (modifiers == -1) |
- ? GetWebMouseEventModifierForButton( |
- current_pointer_state_[kRawMousePointerId].pressed_button_) |
- : modifiers & kButtonsInModifiers; |
-} |
- |
-void EventSender::KeyDown(const std::string& code_str, |
- int modifiers, |
- KeyLocationCode location) { |
- // FIXME: I'm not exactly sure how we should convert the string to a key |
- // event. This seems to work in the cases I tested. |
- // FIXME: Should we also generate a KEY_UP? |
- |
- bool generate_char = false; |
- |
- // Convert \n -> VK_RETURN. Some layout tests use \n to mean "Enter", when |
- // Windows uses \r for "Enter". |
- int code = 0; |
- int text = 0; |
- bool needs_shift_key_modifier = false; |
- std::string domKeyString; |
- std::string domCodeString; |
- |
- if ("Enter" == code_str) { |
- generate_char = true; |
- text = code = ui::VKEY_RETURN; |
- domKeyString.assign("Enter"); |
- domCodeString.assign("Enter"); |
- } else if ("ArrowRight" == code_str) { |
- code = ui::VKEY_RIGHT; |
- domKeyString.assign("ArrowRight"); |
- domCodeString.assign("ArrowRight"); |
- } else if ("ArrowDown" == code_str) { |
- code = ui::VKEY_DOWN; |
- domKeyString.assign("ArrowDown"); |
- domCodeString.assign("ArrowDown"); |
- } else if ("ArrowLeft" == code_str) { |
- code = ui::VKEY_LEFT; |
- domKeyString.assign("ArrowLeft"); |
- domCodeString.assign("ArrowLeft"); |
- } else if ("ArrowUp" == code_str) { |
- code = ui::VKEY_UP; |
- domKeyString.assign("ArrowUp"); |
- domCodeString.assign("ArrowUp"); |
- } else if ("Insert" == code_str) { |
- code = ui::VKEY_INSERT; |
- domKeyString.assign("Insert"); |
- domCodeString.assign("Insert"); |
- } else if ("Delete" == code_str) { |
- code = ui::VKEY_DELETE; |
- domKeyString.assign("Delete"); |
- domCodeString.assign("Delete"); |
- } else if ("PageUp" == code_str) { |
- code = ui::VKEY_PRIOR; |
- domKeyString.assign("PageUp"); |
- domCodeString.assign("PageUp"); |
- } else if ("PageDown" == code_str) { |
- code = ui::VKEY_NEXT; |
- domKeyString.assign("PageDown"); |
- domCodeString.assign("PageDown"); |
- } else if ("Home" == code_str) { |
- code = ui::VKEY_HOME; |
- domKeyString.assign("Home"); |
- domCodeString.assign("Home"); |
- } else if ("End" == code_str) { |
- code = ui::VKEY_END; |
- domKeyString.assign("End"); |
- domCodeString.assign("End"); |
- } else if ("PrintScreen" == code_str) { |
- code = ui::VKEY_SNAPSHOT; |
- domKeyString.assign("PrintScreen"); |
- domCodeString.assign("PrintScreen"); |
- } else if ("ContextMenu" == code_str) { |
- code = ui::VKEY_APPS; |
- domKeyString.assign("ContextMenu"); |
- domCodeString.assign("ContextMenu"); |
- } else if ("ControlLeft" == code_str) { |
- code = ui::VKEY_CONTROL; |
- domKeyString.assign("Control"); |
- domCodeString.assign("ControlLeft"); |
- location = DOMKeyLocationLeft; |
- } else if ("ControlRight" == code_str) { |
- code = ui::VKEY_CONTROL; |
- domKeyString.assign("Control"); |
- domCodeString.assign("ControlRight"); |
- location = DOMKeyLocationRight; |
- } else if ("ShiftLeft" == code_str) { |
- code = ui::VKEY_SHIFT; |
- domKeyString.assign("Shift"); |
- domCodeString.assign("ShiftLeft"); |
- location = DOMKeyLocationLeft; |
- } else if ("ShiftRight" == code_str) { |
- code = ui::VKEY_SHIFT; |
- domKeyString.assign("Shift"); |
- domCodeString.assign("ShiftRight"); |
- location = DOMKeyLocationRight; |
- } else if ("AltLeft" == code_str) { |
- code = ui::VKEY_MENU; |
- domKeyString.assign("Alt"); |
- domCodeString.assign("AltLeft"); |
- location = DOMKeyLocationLeft; |
- } else if ("AltRight" == code_str) { |
- code = ui::VKEY_MENU; |
- domKeyString.assign("Alt"); |
- domCodeString.assign("AltRight"); |
- location = DOMKeyLocationRight; |
- } else if ("NumLock" == code_str) { |
- code = ui::VKEY_NUMLOCK; |
- domKeyString.assign("NumLock"); |
- domCodeString.assign("NumLock"); |
- } else if ("Backspace" == code_str) { |
- code = ui::VKEY_BACK; |
- domKeyString.assign("Backspace"); |
- domCodeString.assign("Backspace"); |
- } else if ("Escape" == code_str) { |
- code = ui::VKEY_ESCAPE; |
- domKeyString.assign("Escape"); |
- domCodeString.assign("Escape"); |
- } else if ("Tab" == code_str) { |
- code = ui::VKEY_TAB; |
- domKeyString.assign("Tab"); |
- domCodeString.assign("Tab"); |
- } else if ("Cut" == code_str || "Copy" == code_str || "Paste" == code_str) { |
- // No valid KeyboardCode for Cut/Copy/Paste. |
- code = 0; |
- domKeyString.assign(code_str); |
- // It's OK to assign the same string as the DomCode strings happens to be |
- // the same for these keys. |
- domCodeString.assign(code_str); |
- } else { |
- // Compare the input string with the function-key names defined by the |
- // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key |
- // name, set its key code. |
- for (int i = 1; i <= 24; ++i) { |
- std::string function_key_name = base::StringPrintf("F%d", i); |
- if (function_key_name == code_str) { |
- code = ui::VKEY_F1 + (i - 1); |
- domKeyString = function_key_name; |
- domCodeString = function_key_name; |
- break; |
- } |
- } |
- if (!code) { |
- base::string16 code_str16 = base::UTF8ToUTF16(code_str); |
- if (code_str16.size() != 1u) { |
- v8::Isolate* isolate = blink::mainThreadIsolate(); |
- isolate->ThrowException(v8::Exception::TypeError( |
- gin::StringToV8(isolate, "Invalid web code."))); |
- return; |
- } |
- text = code = code_str16[0]; |
- needs_shift_key_modifier = base::IsAsciiUpper(code & 0xFF); |
- if (base::IsAsciiLower(code & 0xFF)) |
- code -= 'a' - 'A'; |
- if (base::IsAsciiAlpha(code)) { |
- domKeyString.assign(code_str); |
- domCodeString.assign("Key"); |
- domCodeString.push_back( |
- base::ToUpperASCII(static_cast<base::char16>(code))); |
- } else if (base::IsAsciiDigit(code)) { |
- domKeyString.assign(code_str); |
- domCodeString.assign("Digit"); |
- domCodeString.push_back(code); |
- } else if (code == ' ') { |
- domKeyString.assign(code_str); |
- domCodeString.assign("Space"); |
- } else if (code == 9) { |
- domKeyString.assign("Tab"); |
- domCodeString.assign("Tab"); |
- } |
- generate_char = true; |
- } |
- |
- if ("(" == code_str) { |
- code = '9'; |
- needs_shift_key_modifier = true; |
- domKeyString.assign("("); |
- domCodeString.assign("Digit9"); |
- } |
- } |
- |
- if (needs_shift_key_modifier) |
- modifiers |= WebInputEvent::ShiftKey; |
- |
- // See if KeyLocation argument is given. |
- switch (location) { |
- case DOMKeyLocationStandard: |
- break; |
- case DOMKeyLocationLeft: |
- modifiers |= WebInputEvent::IsLeft; |
- break; |
- case DOMKeyLocationRight: |
- modifiers |= WebInputEvent::IsRight; |
- break; |
- case DOMKeyLocationNumpad: |
- modifiers |= WebInputEvent::IsKeyPad; |
- break; |
- } |
- |
- // For one generated keyboard event, we need to generate a keyDown/keyUp |
- // pair; |
- // On Windows, we might also need to generate a char event to mimic the |
- // Windows event flow; on other platforms we create a merged event and test |
- // the event flow that that platform provides. |
- WebKeyboardEvent event_down(WebInputEvent::RawKeyDown, modifiers, |
- GetCurrentEventTimeSec()); |
- event_down.windowsKeyCode = code; |
- event_down.domKey = static_cast<int>( |
- ui::KeycodeConverter::KeyStringToDomKey(domKeyString)); |
- event_down.domCode = static_cast<int>( |
- ui::KeycodeConverter::CodeStringToDomCode(domCodeString)); |
- |
- if (generate_char) { |
- event_down.text[0] = text; |
- event_down.unmodifiedText[0] = text; |
- } |
- |
- if (event_down.modifiers() != 0) |
- event_down.isSystemKey = IsSystemKeyEvent(event_down); |
- |
- WebKeyboardEvent event_up = event_down; |
- event_up.setType(WebInputEvent::KeyUp); |
- // EventSender.m forces a layout here, with at least one |
- // test (fast/forms/focus-control-to-page.html) relying on this. |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- // In the browser, if a keyboard event corresponds to an editor command, |
- // the command will be dispatched to the renderer just before dispatching |
- // the keyboard event, and then it will be executed in the |
- // RenderView::handleCurrentKeyboardEvent() method. |
- // We just simulate the same behavior here. |
- std::string edit_command; |
- if (GetEditCommand(event_down, &edit_command)) |
- delegate()->SetEditCommand(edit_command, ""); |
- |
- HandleInputEventOnViewOrPopup(event_down); |
- |
- if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) { |
- WebMouseEvent event(WebInputEvent::MouseDown, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &event); |
- FinishDragAndDrop(event, blink::WebDragOperationNone); |
- } |
- |
- delegate()->ClearEditCommand(); |
- |
- if (generate_char) { |
- WebKeyboardEvent event_char = event_up; |
- event_char.setType(WebInputEvent::Char); |
- HandleInputEventOnViewOrPopup(event_char); |
- } |
- |
- HandleInputEventOnViewOrPopup(event_up); |
-} |
- |
-void EventSender::EnableDOMUIEventLogging() {} |
- |
-void EventSender::FireKeyboardEventsToElement() {} |
- |
-void EventSender::ClearKillRing() {} |
- |
-std::vector<std::string> EventSender::ContextClick() { |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- UpdateClickCountForButton(WebMouseEvent::Button::Right); |
- |
- // Clears last context menu data because we need to know if the context menu |
- // be requested after following mouse events. |
- last_context_menu_data_.reset(); |
- |
- // Generate right mouse down and up. |
- // This is a hack to work around only allowing a single pressed button since |
- // we want to test the case where both the left and right mouse buttons are |
- // pressed. |
- // TODO(mustaq): This hack seems unused here! But do we need this hack at all |
- // after adding current_buttons_. |
- if (current_pointer_state_[kRawMousePointerId].pressed_button_ == |
- WebMouseEvent::Button::NoButton) { |
- current_pointer_state_[kRawMousePointerId].pressed_button_ = |
- WebMouseEvent::Button::Right; |
- current_pointer_state_[kRawMousePointerId].current_buttons_ |= |
- GetWebMouseEventModifierForButton( |
- current_pointer_state_[kRawMousePointerId].pressed_button_); |
- } |
- WebMouseEvent event(WebInputEvent::MouseDown, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(WebMouseEvent::Button::Right, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &event); |
- HandleInputEventOnViewOrPopup(event); |
- |
-#if defined(OS_WIN) |
- current_pointer_state_[kRawMousePointerId].current_buttons_ &= |
- ~GetWebMouseEventModifierForButton(WebMouseEvent::Button::Right); |
- current_pointer_state_[kRawMousePointerId].pressed_button_ = |
- WebMouseEvent::Button::NoButton; |
- |
- WebMouseEvent mouseUpEvent(WebInputEvent::MouseUp, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(WebMouseEvent::Button::Right, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &mouseUpEvent); |
- HandleInputEventOnViewOrPopup(mouseUpEvent); |
-#endif |
- |
- std::vector<std::string> menu_items = |
- MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate()); |
- last_context_menu_data_.reset(); |
- return menu_items; |
-} |
- |
-void EventSender::TextZoomIn() { |
- view()->setTextZoomFactor(view()->textZoomFactor() * 1.2f); |
-} |
- |
-void EventSender::TextZoomOut() { |
- view()->setTextZoomFactor(view()->textZoomFactor() / 1.2f); |
-} |
- |
-void EventSender::ZoomPageIn() { |
- const std::vector<WebViewTestProxyBase*>& window_list = |
- interfaces()->GetWindowList(); |
- |
- for (size_t i = 0; i < window_list.size(); ++i) { |
- window_list.at(i)->web_view()->setZoomLevel( |
- window_list.at(i)->web_view()->zoomLevel() + 1); |
- } |
-} |
- |
-void EventSender::ZoomPageOut() { |
- const std::vector<WebViewTestProxyBase*>& window_list = |
- interfaces()->GetWindowList(); |
- |
- for (size_t i = 0; i < window_list.size(); ++i) { |
- window_list.at(i)->web_view()->setZoomLevel( |
- window_list.at(i)->web_view()->zoomLevel() - 1); |
- } |
-} |
- |
-void EventSender::SetPageZoomFactor(double zoom_factor) { |
- const std::vector<WebViewTestProxyBase*>& window_list = |
- interfaces()->GetWindowList(); |
- |
- for (size_t i = 0; i < window_list.size(); ++i) { |
- window_list.at(i)->web_view()->setZoomLevel(std::log(zoom_factor) / |
- std::log(1.2)); |
- } |
-} |
- |
-void EventSender::ClearTouchPoints() { |
- touch_points_.clear(); |
-} |
- |
-void EventSender::ThrowTouchPointError() { |
- v8::Isolate* isolate = blink::mainThreadIsolate(); |
- isolate->ThrowException(v8::Exception::TypeError( |
- gin::StringToV8(isolate, "Invalid touch point."))); |
-} |
- |
-void EventSender::ReleaseTouchPoint(unsigned index) { |
- if (index >= touch_points_.size()) { |
- ThrowTouchPointError(); |
- return; |
- } |
- |
- WebTouchPoint* touch_point = &touch_points_[index]; |
- touch_point->state = WebTouchPoint::StateReleased; |
-} |
- |
-void EventSender::UpdateTouchPoint(unsigned index, |
- float x, |
- float y, |
- gin::Arguments* args) { |
- if (index >= touch_points_.size()) { |
- ThrowTouchPointError(); |
- return; |
- } |
- |
- WebTouchPoint* touch_point = &touch_points_[index]; |
- touch_point->state = WebTouchPoint::StateMoved; |
- touch_point->position = WebFloatPoint(x, y); |
- touch_point->screenPosition = touch_point->position; |
- |
- InitPointerProperties(args, touch_point, &touch_point->radiusX, |
- &touch_point->radiusY); |
-} |
- |
-void EventSender::CancelTouchPoint(unsigned index) { |
- if (index >= touch_points_.size()) { |
- ThrowTouchPointError(); |
- return; |
- } |
- |
- WebTouchPoint* touch_point = &touch_points_[index]; |
- touch_point->state = WebTouchPoint::StateCancelled; |
-} |
- |
-void EventSender::SetTouchModifier(const std::string& key_name, |
- bool set_mask) { |
- int mask = GetKeyModifier(key_name); |
- |
- if (set_mask) |
- touch_modifiers_ |= mask; |
- else |
- touch_modifiers_ &= ~mask; |
-} |
- |
-void EventSender::SetTouchCancelable(bool cancelable) { |
- touch_cancelable_ = cancelable; |
-} |
- |
-void EventSender::DumpFilenameBeingDragged() { |
- if (current_drag_data_.isNull()) |
- return; |
- |
- WebVector<WebDragData::Item> items = current_drag_data_.items(); |
- for (size_t i = 0; i < items.size(); ++i) { |
- if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) { |
- WebURL url = items[i].binaryDataSourceURL; |
- WebString filename_extension = items[i].binaryDataFilenameExtension; |
- WebString content_disposition = items[i].binaryDataContentDisposition; |
- base::FilePath filename = |
- net::GenerateFileName(url, content_disposition.utf8(), |
- std::string(), // referrer_charset |
- std::string(), // suggested_name |
- std::string(), // mime_type |
- std::string()); // default_name |
-#if defined(OS_WIN) |
- filename = filename.ReplaceExtension(filename_extension.utf16()); |
-#else |
- filename = filename.ReplaceExtension(filename_extension.utf8()); |
-#endif |
- delegate()->PrintMessage(std::string("Filename being dragged: ") + |
- filename.AsUTF8Unsafe() + "\n"); |
- return; |
- } |
- } |
-} |
- |
-void EventSender::GestureFlingCancel() { |
- WebGestureEvent event(WebInputEvent::GestureFlingCancel, |
- WebInputEvent::NoModifiers, GetCurrentEventTimeSec()); |
- // Generally it won't matter what device we use here, and since it might |
- // be cumbersome to expect all callers to specify a device, we'll just |
- // choose Touchpad here. |
- event.sourceDevice = blink::WebGestureDeviceTouchpad; |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- HandleInputEventOnViewOrPopup(event); |
-} |
- |
-void EventSender::GestureFlingStart(float x, |
- float y, |
- float velocity_x, |
- float velocity_y, |
- gin::Arguments* args) { |
- WebGestureEvent event(WebInputEvent::GestureFlingStart, |
- WebInputEvent::NoModifiers, GetCurrentEventTimeSec()); |
- |
- std::string device_string; |
- if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) |
- args->GetNext(&device_string); |
- |
- if (device_string == kSourceDeviceStringTouchpad) { |
- event.sourceDevice = blink::WebGestureDeviceTouchpad; |
- } else if (device_string == kSourceDeviceStringTouchscreen) { |
- event.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- } else { |
- args->ThrowError(); |
- return; |
- } |
- |
- float max_start_velocity = std::max(fabs(velocity_x), fabs(velocity_y)); |
- if (!max_start_velocity) { |
- v8::Isolate* isolate = blink::mainThreadIsolate(); |
- isolate->ThrowException(v8::Exception::TypeError( |
- gin::StringToV8(isolate, "Invalid max start velocity."))); |
- return; |
- } |
- |
- event.x = x; |
- event.y = y; |
- event.globalX = event.x; |
- event.globalY = event.y; |
- |
- event.data.flingStart.velocityX = velocity_x; |
- event.data.flingStart.velocityY = velocity_y; |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- HandleInputEventOnViewOrPopup(event); |
-} |
- |
-bool EventSender::IsFlinging() const { |
- return view()->isFlinging(); |
-} |
- |
-void EventSender::GestureScrollFirstPoint(int x, int y) { |
- current_gesture_location_ = WebPoint(x, y); |
-} |
- |
-void EventSender::TouchStart(gin::Arguments* args) { |
- SendCurrentTouchEvent(WebInputEvent::TouchStart, args); |
-} |
- |
-void EventSender::TouchMove(gin::Arguments* args) { |
- SendCurrentTouchEvent(WebInputEvent::TouchMove, args); |
-} |
- |
-void EventSender::TouchCancel(gin::Arguments* args) { |
- SendCurrentTouchEvent(WebInputEvent::TouchCancel, args); |
-} |
- |
-void EventSender::TouchEnd(gin::Arguments* args) { |
- SendCurrentTouchEvent(WebInputEvent::TouchEnd, args); |
-} |
- |
-void EventSender::NotifyStartOfTouchScroll() { |
- WebTouchEvent event(WebInputEvent::TouchScrollStarted, |
- WebInputEvent::NoModifiers, GetCurrentEventTimeSec()); |
- HandleInputEventOnViewOrPopup(event); |
-} |
- |
-void EventSender::LeapForward(int milliseconds) { |
- if (is_drag_mode_ && |
- current_pointer_state_[kRawMousePointerId].pressed_button_ == |
- WebMouseEvent::Button::Left && |
- !replaying_saved_events_) { |
- SavedEvent saved_event; |
- saved_event.type = SavedEvent::TYPE_LEAP_FORWARD; |
- saved_event.milliseconds = milliseconds; |
- mouse_event_queue_.push_back(saved_event); |
- } else { |
- DoLeapForward(milliseconds); |
- } |
-} |
- |
-void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) { |
- if (!current_drag_data_.isNull()) { |
- // Nested dragging not supported, fuzzer code a likely culprit. |
- // Cancel the current drag operation and throw an error. |
- KeyDown("Escape", 0, DOMKeyLocationStandard); |
- v8::Isolate* isolate = blink::mainThreadIsolate(); |
- isolate->ThrowException(v8::Exception::Error( |
- gin::StringToV8(isolate, |
- "Nested beginDragWithFiles() not supported."))); |
- return; |
- } |
- current_drag_data_.initialize(); |
- WebVector<WebString> absolute_filenames(files.size()); |
- for (size_t i = 0; i < files.size(); ++i) { |
- WebDragData::Item item; |
- item.storageType = WebDragData::Item::StorageTypeFilename; |
- item.filenameData = delegate()->GetAbsoluteWebStringFromUTF8Path(files[i]); |
- current_drag_data_.addItem(item); |
- absolute_filenames[i] = item.filenameData; |
- } |
- current_drag_data_.setFilesystemId( |
- delegate()->RegisterIsolatedFileSystem(absolute_filenames)); |
- current_drag_effects_allowed_ = blink::WebDragOperationCopy; |
- |
- const WebPoint& last_pos = |
- current_pointer_state_[kRawMousePointerId].last_pos_; |
- float scale = delegate()->GetWindowToViewportScale(); |
- WebPoint scaled_last_pos(last_pos.x * scale, last_pos.y * scale); |
- |
- // Provide a drag source. |
- mainFrameWidget()->dragTargetDragEnter( |
- current_drag_data_, scaled_last_pos, scaled_last_pos, |
- current_drag_effects_allowed_, 0); |
- // |is_drag_mode_| saves events and then replays them later. We don't |
- // need/want that. |
- is_drag_mode_ = false; |
- |
- // Make the rest of eventSender think a drag is in progress. |
- current_pointer_state_[kRawMousePointerId].pressed_button_ = |
- WebMouseEvent::Button::Left; |
- current_pointer_state_[kRawMousePointerId].current_buttons_ |= |
- GetWebMouseEventModifierForButton( |
- current_pointer_state_[kRawMousePointerId].pressed_button_); |
-} |
- |
-void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) { |
- WebTouchPoint touch_point; |
- touch_point.pointerType = WebPointerProperties::PointerType::Touch; |
- touch_point.state = WebTouchPoint::StatePressed; |
- touch_point.position = WebFloatPoint(x, y); |
- touch_point.screenPosition = touch_point.position; |
- |
- int highest_id = -1; |
- for (size_t i = 0; i < touch_points_.size(); i++) { |
- if (touch_points_[i].id > highest_id) |
- highest_id = touch_points_[i].id; |
- } |
- touch_point.id = highest_id + 1; |
- |
- InitPointerProperties(args, &touch_point, &touch_point.radiusX, |
- &touch_point.radiusY); |
- |
- // Set the touch point pressure to zero if it was not set by the caller |
- if (std::isnan(touch_point.force)) |
- touch_point.force = 0.0; |
- |
- touch_points_.push_back(touch_point); |
-} |
- |
-void EventSender::GestureScrollBegin(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureScrollBegin, args); |
-} |
- |
-void EventSender::GestureScrollEnd(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureScrollEnd, args); |
-} |
- |
-void EventSender::GestureScrollUpdate(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureScrollUpdate, args); |
-} |
- |
-void EventSender::GesturePinchBegin(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GesturePinchBegin, args); |
-} |
- |
-void EventSender::GesturePinchEnd(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GesturePinchEnd, args); |
-} |
- |
-void EventSender::GesturePinchUpdate(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GesturePinchUpdate, args); |
-} |
- |
-void EventSender::GestureTap(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureTap, args); |
-} |
- |
-void EventSender::GestureTapDown(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureTapDown, args); |
-} |
- |
-void EventSender::GestureShowPress(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureShowPress, args); |
-} |
- |
-void EventSender::GestureTapCancel(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureTapCancel, args); |
-} |
- |
-void EventSender::GestureLongPress(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureLongPress, args); |
-} |
- |
-void EventSender::GestureLongTap(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureLongTap, args); |
-} |
- |
-void EventSender::GestureTwoFingerTap(gin::Arguments* args) { |
- GestureEvent(WebInputEvent::GestureTwoFingerTap, args); |
-} |
- |
-void EventSender::MouseScrollBy(gin::Arguments* args, |
- MouseScrollType scroll_type) { |
- // TODO(dtapuska): Gestures really should be sent by the MouseWheelEventQueue |
- // class in the browser. But since the event doesn't propogate up into |
- // the browser generate the events here. See crbug.com/596095. |
- bool send_gestures = true; |
- WebMouseWheelEvent wheel_event = |
- GetMouseWheelEvent(args, scroll_type, &send_gestures); |
- if (wheel_event.type() != WebInputEvent::Undefined && |
- HandleInputEventOnViewOrPopup(wheel_event) == |
- WebInputEventResult::NotHandled && |
- send_gestures) { |
- SendGesturesForMouseWheelEvent(wheel_event); |
- } |
-} |
- |
-void EventSender::MouseMoveTo(gin::Arguments* args) { |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- double x; |
- double y; |
- if (!args->GetNext(&x) || !args->GetNext(&y)) { |
- args->ThrowError(); |
- return; |
- } |
- WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y)); |
- |
- int modifiers = 0; |
- if (!args->PeekNext().IsEmpty()) { |
- modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext()); |
- args->Skip(); |
- } |
- |
- WebPointerProperties::PointerType pointerType = |
- WebPointerProperties::PointerType::Mouse; |
- int pointerId = 0; |
- float pressure = 0; |
- int tiltX = 0; |
- int tiltY = 0; |
- if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure, |
- tiltX, tiltY)) |
- return; |
- |
- if (pointerType == WebPointerProperties::PointerType::Mouse && |
- is_drag_mode_ && !replaying_saved_events_ && |
- current_pointer_state_[kRawMousePointerId].pressed_button_ == |
- WebMouseEvent::Button::Left) { |
- SavedEvent saved_event; |
- saved_event.type = SavedEvent::TYPE_MOUSE_MOVE; |
- saved_event.pos = mouse_pos; |
- saved_event.modifiers = modifiers; |
- mouse_event_queue_.push_back(saved_event); |
- } else { |
- current_pointer_state_[pointerId].last_pos_ = mouse_pos; |
- current_pointer_state_[pointerId].modifiers_ = modifiers; |
- WebMouseEvent event(WebInputEvent::MouseMove, |
- ModifiersForPointer(pointerId), |
- GetCurrentEventTimeSec()); |
- int click_count = pointerType == WebPointerProperties::PointerType::Mouse |
- ? click_count_ |
- : 0; |
- InitMouseEventGeneric( |
- current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos, |
- click_count, pointerType, pointerId, pressure, tiltX, tiltY, &event); |
- HandleInputEventOnViewOrPopup(event); |
- if (pointerType == WebPointerProperties::PointerType::Mouse) |
- DoDragAfterMouseMove(event); |
- } |
-} |
- |
-void EventSender::MouseLeave() { |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- WebMouseEvent event(WebInputEvent::MouseLeave, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(WebMouseEvent::Button::NoButton, 0, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &event); |
- HandleInputEventOnViewOrPopup(event); |
-} |
- |
- |
-void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) { |
- delegate()->PostTask(base::Bind(&EventSender::MouseDown, |
- weak_factory_.GetWeakPtr(), button_number, |
- modifiers)); |
- delegate()->PostTask(base::Bind(&EventSender::MouseUp, |
- weak_factory_.GetWeakPtr(), button_number, |
- modifiers)); |
-} |
- |
-void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str, |
- int modifiers, |
- KeyLocationCode location) { |
- delegate()->PostTask(base::Bind(&EventSender::KeyDown, |
- weak_factory_.GetWeakPtr(), code_str, |
- modifiers, location)); |
-} |
- |
-double EventSender::GetCurrentEventTimeSec() { |
- return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF() + |
- time_offset_ms_ / 1000.0; |
-} |
- |
-void EventSender::DoLeapForward(int milliseconds) { |
- time_offset_ms_ += milliseconds; |
-} |
- |
-uint32_t EventSender::GetUniqueTouchEventId(gin::Arguments* args) { |
- uint32_t unique_touch_event_id; |
- if(!args->PeekNext().IsEmpty() && args->GetNext(&unique_touch_event_id)) |
- return unique_touch_event_id; |
- |
- return 0; |
-} |
- |
-void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type, |
- gin::Arguments* args) { |
- uint32_t unique_touch_event_id = GetUniqueTouchEventId(args); |
- |
- DCHECK_GT(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap), |
- touch_points_.size()); |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- WebTouchEvent touch_event(type, touch_modifiers_, GetCurrentEventTimeSec()); |
- touch_event.dispatchType = touch_cancelable_ |
- ? WebInputEvent::Blocking |
- : WebInputEvent::EventNonBlocking; |
- touch_event.movedBeyondSlopRegion = true; |
- touch_event.uniqueTouchEventId = unique_touch_event_id; |
- touch_event.touchesLength = touch_points_.size(); |
- for (size_t i = 0; i < touch_points_.size(); ++i) |
- touch_event.touches[i] = touch_points_[i]; |
- HandleInputEventOnViewOrPopup(touch_event); |
- |
- for (size_t i = 0; i < touch_points_.size(); ++i) { |
- WebTouchPoint* touch_point = &touch_points_[i]; |
- if (touch_point->state == WebTouchPoint::StateReleased |
- || touch_point->state == WebTouchPoint::StateCancelled) { |
- touch_points_.erase(touch_points_.begin() + i); |
- --i; |
- } else { |
- touch_point->state = WebTouchPoint::StateStationary; |
- } |
- } |
-} |
- |
-void EventSender::GestureEvent(WebInputEvent::Type type, |
- gin::Arguments* args) { |
- WebGestureEvent event(type, WebInputEvent::NoModifiers, |
- GetCurrentEventTimeSec()); |
- |
- // If the first argument is a string, it is to specify the device, otherwise |
- // the device is assumed to be a touchscreen (since most tests were written |
- // assuming this). |
- event.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) { |
- std::string device_string; |
- if (!args->GetNext(&device_string)) { |
- args->ThrowError(); |
- return; |
- } |
- if (device_string == kSourceDeviceStringTouchpad) { |
- event.sourceDevice = blink::WebGestureDeviceTouchpad; |
- } else if (device_string == kSourceDeviceStringTouchscreen) { |
- event.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- } else { |
- args->ThrowError(); |
- return; |
- } |
- } |
- |
- double x; |
- double y; |
- if (!args->GetNext(&x) || !args->GetNext(&y)) { |
- args->ThrowError(); |
- return; |
- } |
- |
- switch (type) { |
- case WebInputEvent::GestureScrollUpdate: |
- { |
- bool preventPropagation = false; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&preventPropagation)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- if (!GetScrollUnits(args, &event.data.scrollUpdate.deltaUnits)) |
- return; |
- |
- event.data.scrollUpdate.deltaX = static_cast<float>(x); |
- event.data.scrollUpdate.deltaY = static_cast<float>(y); |
- event.data.scrollUpdate.preventPropagation = preventPropagation; |
- event.x = current_gesture_location_.x; |
- event.y = current_gesture_location_.y; |
- current_gesture_location_.x = |
- current_gesture_location_.x + event.data.scrollUpdate.deltaX; |
- current_gesture_location_.y = |
- current_gesture_location_.y + event.data.scrollUpdate.deltaY; |
- break; |
- } |
- case WebInputEvent::GestureScrollBegin: |
- current_gesture_location_ = WebPoint(x, y); |
- event.x = current_gesture_location_.x; |
- event.y = current_gesture_location_.y; |
- break; |
- case WebInputEvent::GestureScrollEnd: |
- case WebInputEvent::GestureFlingStart: |
- event.x = current_gesture_location_.x; |
- event.y = current_gesture_location_.y; |
- break; |
- case WebInputEvent::GesturePinchBegin: |
- case WebInputEvent::GesturePinchEnd: |
- current_gesture_location_ = WebPoint(x, y); |
- event.x = current_gesture_location_.x; |
- event.y = current_gesture_location_.y; |
- break; |
- case WebInputEvent::GesturePinchUpdate: |
- { |
- float scale = 1; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&scale)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- event.data.pinchUpdate.scale = scale; |
- current_gesture_location_ = WebPoint(x, y); |
- event.x = current_gesture_location_.x; |
- event.y = current_gesture_location_.y; |
- break; |
- } |
- case WebInputEvent::GestureTap: |
- { |
- float tap_count = 1; |
- float width = 30; |
- float height = 30; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&tap_count)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&width)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&height)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- event.data.tap.tapCount = tap_count; |
- event.data.tap.width = width; |
- event.data.tap.height = height; |
- event.x = x; |
- event.y = y; |
- break; |
- } |
- case WebInputEvent::GestureTapUnconfirmed: |
- if (!args->PeekNext().IsEmpty()) { |
- float tap_count; |
- if (!args->GetNext(&tap_count)) { |
- args->ThrowError(); |
- return; |
- } |
- event.data.tap.tapCount = tap_count; |
- } else { |
- event.data.tap.tapCount = 1; |
- } |
- event.x = x; |
- event.y = y; |
- break; |
- case WebInputEvent::GestureTapDown: |
- { |
- float width = 30; |
- float height = 30; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&width)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&height)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- event.x = x; |
- event.y = y; |
- event.data.tapDown.width = width; |
- event.data.tapDown.height = height; |
- break; |
- } |
- case WebInputEvent::GestureShowPress: |
- { |
- float width = 30; |
- float height = 30; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&width)) { |
- args->ThrowError(); |
- return; |
- } |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&height)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- } |
- event.x = x; |
- event.y = y; |
- event.data.showPress.width = width; |
- event.data.showPress.height = height; |
- break; |
- } |
- case WebInputEvent::GestureTapCancel: |
- event.x = x; |
- event.y = y; |
- break; |
- case WebInputEvent::GestureLongPress: |
- case WebInputEvent::GestureLongTap: |
- event.x = x; |
- event.y = y; |
- if (!args->PeekNext().IsEmpty()) { |
- float width; |
- if (!args->GetNext(&width)) { |
- args->ThrowError(); |
- return; |
- } |
- event.data.longPress.width = width; |
- if (!args->PeekNext().IsEmpty()) { |
- float height; |
- if (!args->GetNext(&height)) { |
- args->ThrowError(); |
- return; |
- } |
- event.data.longPress.height = height; |
- } |
- } |
- break; |
- case WebInputEvent::GestureTwoFingerTap: |
- event.x = x; |
- event.y = y; |
- if (!args->PeekNext().IsEmpty()) { |
- float first_finger_width; |
- if (!args->GetNext(&first_finger_width)) { |
- args->ThrowError(); |
- return; |
- } |
- event.data.twoFingerTap.firstFingerWidth = first_finger_width; |
- if (!args->PeekNext().IsEmpty()) { |
- float first_finger_height; |
- if (!args->GetNext(&first_finger_height)) { |
- args->ThrowError(); |
- return; |
- } |
- event.data.twoFingerTap.firstFingerHeight = first_finger_height; |
- } |
- } |
- break; |
- default: |
- NOTREACHED(); |
- } |
- |
- event.uniqueTouchEventId = GetUniqueTouchEventId(args); |
- |
- event.globalX = event.x; |
- event.globalY = event.y; |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- WebInputEventResult result = HandleInputEventOnViewOrPopup(event); |
- |
- // Long press might start a drag drop session. Complete it if so. |
- if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) { |
- WebMouseEvent mouse_event(WebInputEvent::MouseDown, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- |
- InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- WebPoint(x, y), click_count_, &mouse_event); |
- |
- FinishDragAndDrop(mouse_event, blink::WebDragOperationNone); |
- } |
- args->Return(result != WebInputEventResult::NotHandled); |
-} |
- |
-void EventSender::UpdateClickCountForButton( |
- WebMouseEvent::Button button_type) { |
- if ((GetCurrentEventTimeSec() - last_click_time_sec_ < |
- kMultipleClickTimeSec) && |
- (!OutsideMultiClickRadius( |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- last_click_pos_)) && |
- (button_type == last_button_type_)) { |
- ++click_count_; |
- } else { |
- click_count_ = 1; |
- last_button_type_ = button_type; |
- } |
-} |
- |
-WebMouseWheelEvent EventSender::GetMouseWheelEvent(gin::Arguments* args, |
- MouseScrollType scroll_type, |
- bool* send_gestures) { |
- // Force a layout here just to make sure every position has been |
- // determined before we send events (as well as all the other methods |
- // that send an event do). |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- double horizontal; |
- double vertical; |
- if (!args->GetNext(&horizontal) || !args->GetNext(&vertical)) { |
- args->ThrowError(); |
- return WebMouseWheelEvent(); |
- } |
- |
- bool paged = false; |
- bool has_precise_scrolling_deltas = false; |
- int modifiers = 0; |
- WebMouseWheelEvent::Phase phase = WebMouseWheelEvent::PhaseNone; |
- if (!args->PeekNext().IsEmpty()) { |
- args->GetNext(&paged); |
- if (!args->PeekNext().IsEmpty()) { |
- args->GetNext(&has_precise_scrolling_deltas); |
- if (!args->PeekNext().IsEmpty()) { |
- v8::Local<v8::Value> value; |
- args->GetNext(&value); |
- modifiers = GetKeyModifiersFromV8(args->isolate(), value); |
- if (!args->PeekNext().IsEmpty()) { |
- args->GetNext(send_gestures); |
- if (!args->PeekNext().IsEmpty()) { |
- v8::Local<v8::Value> phase_value; |
- args->GetNext(&phase_value); |
- phase = GetMouseWheelEventPhaseFromV8(phase_value); |
- } |
- } |
- } |
- } |
- } |
- |
- current_pointer_state_[kRawMousePointerId].modifiers_ = modifiers; |
- WebMouseWheelEvent event(WebInputEvent::MouseWheel, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, |
- click_count_, &event); |
- event.wheelTicksX = static_cast<float>(horizontal); |
- event.wheelTicksY = static_cast<float>(vertical); |
- event.deltaX = event.wheelTicksX; |
- event.deltaY = event.wheelTicksY; |
- event.scrollByPage = paged; |
- event.hasPreciseScrollingDeltas = has_precise_scrolling_deltas; |
- event.phase = phase; |
- if (scroll_type == MouseScrollType::PIXEL) { |
- event.wheelTicksX /= kScrollbarPixelsPerTick; |
- event.wheelTicksY /= kScrollbarPixelsPerTick; |
- } else { |
- event.deltaX *= kScrollbarPixelsPerTick; |
- event.deltaY *= kScrollbarPixelsPerTick; |
- } |
- return event; |
-} |
- |
-// Radius fields radius_x and radius_y should eventually be moved to |
-// WebPointerProperties. |
-// TODO(e_hakkinen): Drop radius_{x,y}_pointer parameters once that happens. |
-void EventSender::InitPointerProperties(gin::Arguments* args, |
- WebPointerProperties* e, |
- float* radius_x_pointer, |
- float* radius_y_pointer) { |
- if (!args->PeekNext().IsEmpty()) { |
- double radius_x; |
- if (!args->GetNext(&radius_x)) { |
- args->ThrowError(); |
- return; |
- } |
- |
- double radius_y = radius_x; |
- if (!args->PeekNext().IsEmpty()) { |
- if (!args->GetNext(&radius_y)) { |
- args->ThrowError(); |
- return; |
- } |
- } |
- |
- *radius_x_pointer = static_cast<float>(radius_x); |
- *radius_y_pointer = static_cast<float>(radius_y); |
- } |
- |
- if (!args->PeekNext().IsEmpty()) { |
- double force; |
- if (!args->GetNext(&force)) { |
- args->ThrowError(); |
- return; |
- } |
- e->force = static_cast<float>(force); |
- } |
- |
- if (!args->PeekNext().IsEmpty()) { |
- int tiltX, tiltY; |
- if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) { |
- args->ThrowError(); |
- return; |
- } |
- e->tiltX = tiltX; |
- e->tiltY = tiltY; |
- } |
- |
- if (!getPointerType(args, false, e->pointerType)) |
- return; |
-} |
- |
-void EventSender::FinishDragAndDrop(const WebMouseEvent& raw_event, |
- blink::WebDragOperation drag_effect) { |
- std::unique_ptr<WebInputEvent> widget_event = |
- TransformScreenToWidgetCoordinates(raw_event); |
- const WebMouseEvent* event = |
- widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get()) |
- : &raw_event; |
- |
- WebPoint client_point(event->x, event->y); |
- WebPoint screen_point(event->globalX, event->globalY); |
- current_drag_effect_ = drag_effect; |
- if (current_drag_effect_) { |
- // Specifically pass any keyboard modifiers to the drop method. This allows |
- // tests to control the drop type (i.e. copy or move). |
- mainFrameWidget()->dragTargetDrop(current_drag_data_, client_point, |
- screen_point, event->modifiers()); |
- } else { |
- mainFrameWidget()->dragTargetDragLeave(blink::WebPoint(), |
- blink::WebPoint()); |
- } |
- current_drag_data_.reset(); |
- mainFrameWidget()->dragSourceEndedAt(client_point, screen_point, |
- current_drag_effect_); |
- mainFrameWidget()->dragSourceSystemDragEnded(); |
-} |
- |
-void EventSender::DoDragAfterMouseUp(const WebMouseEvent& raw_event) { |
- std::unique_ptr<WebInputEvent> widget_event = |
- TransformScreenToWidgetCoordinates(raw_event); |
- const WebMouseEvent* event = |
- widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get()) |
- : &raw_event; |
- |
- last_click_time_sec_ = event->timeStampSeconds(); |
- last_click_pos_ = current_pointer_state_[kRawMousePointerId].last_pos_; |
- |
- // If we're in a drag operation, complete it. |
- if (current_drag_data_.isNull()) |
- return; |
- |
- WebPoint client_point(event->x, event->y); |
- WebPoint screen_point(event->globalX, event->globalY); |
- blink::WebDragOperation drag_effect = mainFrameWidget()->dragTargetDragOver( |
- client_point, screen_point, current_drag_effects_allowed_, |
- event->modifiers()); |
- |
- // Bail if dragover caused cancellation. |
- if (current_drag_data_.isNull()) |
- return; |
- |
- FinishDragAndDrop(raw_event, drag_effect); |
-} |
- |
-void EventSender::DoDragAfterMouseMove(const WebMouseEvent& raw_event) { |
- if (current_pointer_state_[kRawMousePointerId].pressed_button_ == |
- WebMouseEvent::Button::NoButton || |
- current_drag_data_.isNull()) { |
- return; |
- } |
- |
- std::unique_ptr<WebInputEvent> widget_event = |
- TransformScreenToWidgetCoordinates(raw_event); |
- const WebMouseEvent* event = |
- widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get()) |
- : &raw_event; |
- |
- WebPoint client_point(event->x, event->y); |
- WebPoint screen_point(event->globalX, event->globalY); |
- current_drag_effect_ = mainFrameWidget()->dragTargetDragOver( |
- client_point, screen_point, current_drag_effects_allowed_, |
- event->modifiers()); |
-} |
- |
-void EventSender::ReplaySavedEvents() { |
- replaying_saved_events_ = true; |
- while (!mouse_event_queue_.empty()) { |
- SavedEvent e = mouse_event_queue_.front(); |
- mouse_event_queue_.pop_front(); |
- |
- switch (e.type) { |
- case SavedEvent::TYPE_MOUSE_MOVE: { |
- current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers; |
- WebMouseEvent event(WebInputEvent::MouseMove, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent( |
- current_pointer_state_[kRawMousePointerId].pressed_button_, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos, |
- click_count_, &event); |
- current_pointer_state_[kRawMousePointerId].last_pos_ = |
- WebPoint(event.x, event.y); |
- HandleInputEventOnViewOrPopup(event); |
- DoDragAfterMouseMove(event); |
- break; |
- } |
- case SavedEvent::TYPE_LEAP_FORWARD: |
- DoLeapForward(e.milliseconds); |
- break; |
- case SavedEvent::TYPE_MOUSE_UP: { |
- current_pointer_state_[kRawMousePointerId].current_buttons_ &= |
- ~GetWebMouseEventModifierForButton(e.button_type); |
- current_pointer_state_[kRawMousePointerId].pressed_button_ = |
- WebMouseEvent::Button::NoButton; |
- current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers; |
- |
- WebMouseEvent event(WebInputEvent::MouseUp, |
- ModifiersForPointer(kRawMousePointerId), |
- GetCurrentEventTimeSec()); |
- InitMouseEvent( |
- e.button_type, |
- current_pointer_state_[kRawMousePointerId].current_buttons_, |
- current_pointer_state_[kRawMousePointerId].last_pos_, click_count_, |
- &event); |
- HandleInputEventOnViewOrPopup(event); |
- DoDragAfterMouseUp(event); |
- break; |
- } |
- default: |
- NOTREACHED(); |
- } |
- } |
- |
- replaying_saved_events_ = false; |
-} |
- |
-WebInputEventResult EventSender::HandleInputEventOnViewOrPopup( |
- const WebInputEvent& raw_event) { |
- last_event_timestamp_ = raw_event.timeStampSeconds(); |
- |
- WebPagePopup* popup = widget()->pagePopup(); |
- if (popup && !WebInputEvent::isKeyboardEventType(raw_event.type())) { |
- // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the |
- // event does not have to be converted. |
- std::unique_ptr<WebInputEvent> scaled_event = ui::ScaleWebInputEvent( |
- raw_event, delegate()->GetWindowToViewportScale()); |
- const WebInputEvent* popup_friendly_event = |
- scaled_event.get() ? scaled_event.get() : &raw_event; |
- return popup->handleInputEvent( |
- blink::WebCoalescedInputEvent(*popup_friendly_event)); |
- } |
- |
- std::unique_ptr<WebInputEvent> widget_event = |
- TransformScreenToWidgetCoordinates(raw_event); |
- const WebInputEvent* event = |
- widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get()) |
- : &raw_event; |
- return widget()->handleInputEvent(blink::WebCoalescedInputEvent(*event)); |
-} |
- |
-void EventSender::SendGesturesForMouseWheelEvent( |
- const WebMouseWheelEvent wheel_event) { |
- WebGestureEvent begin_event(WebInputEvent::GestureScrollBegin, |
- wheel_event.modifiers(), |
- GetCurrentEventTimeSec()); |
- InitGestureEventFromMouseWheel(wheel_event, &begin_event); |
- begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX; |
- begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY; |
- if (wheel_event.scrollByPage) { |
- begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page; |
- if (begin_event.data.scrollBegin.deltaXHint) { |
- begin_event.data.scrollBegin.deltaXHint = |
- begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1; |
- } |
- if (begin_event.data.scrollBegin.deltaYHint) { |
- begin_event.data.scrollBegin.deltaYHint = |
- begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1; |
- } |
- } else { |
- begin_event.data.scrollBegin.deltaHintUnits = |
- wheel_event.hasPreciseScrollingDeltas |
- ? blink::WebGestureEvent::PrecisePixels |
- : blink::WebGestureEvent::Pixels; |
- } |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- |
- HandleInputEventOnViewOrPopup(begin_event); |
- |
- WebGestureEvent update_event(WebInputEvent::GestureScrollUpdate, |
- wheel_event.modifiers(), |
- GetCurrentEventTimeSec()); |
- InitGestureEventFromMouseWheel(wheel_event, &update_event); |
- update_event.data.scrollUpdate.deltaX = |
- begin_event.data.scrollBegin.deltaXHint; |
- update_event.data.scrollUpdate.deltaY = |
- begin_event.data.scrollBegin.deltaYHint; |
- update_event.data.scrollUpdate.deltaUnits = |
- begin_event.data.scrollBegin.deltaHintUnits; |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- HandleInputEventOnViewOrPopup(update_event); |
- |
- WebGestureEvent end_event(WebInputEvent::GestureScrollEnd, |
- wheel_event.modifiers(), GetCurrentEventTimeSec()); |
- InitGestureEventFromMouseWheel(wheel_event, &end_event); |
- end_event.data.scrollEnd.deltaUnits = |
- begin_event.data.scrollBegin.deltaHintUnits; |
- |
- if (force_layout_on_events_) |
- widget()->updateAllLifecyclePhases(); |
- HandleInputEventOnViewOrPopup(end_event); |
-} |
- |
-TestInterfaces* EventSender::interfaces() { |
- return web_widget_test_proxy_base_->web_view_test_proxy_base() |
- ->test_interfaces(); |
-} |
- |
-WebTestDelegate* EventSender::delegate() { |
- return web_widget_test_proxy_base_->web_view_test_proxy_base()->delegate(); |
-} |
- |
-const blink::WebView* EventSender::view() const { |
- return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view(); |
-} |
- |
-blink::WebView* EventSender::view() { |
- return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view(); |
-} |
- |
-blink::WebWidget* EventSender::widget() { |
- return web_widget_test_proxy_base_->web_widget(); |
-} |
- |
-blink::WebFrameWidget* EventSender::mainFrameWidget() { |
- return view()->mainFrame()->toWebLocalFrame()->frameWidget(); |
-} |
- |
-std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates( |
- const WebInputEvent& event) { |
- return delegate()->TransformScreenToWidgetCoordinates( |
- web_widget_test_proxy_base_, event); |
-} |
- |
-} // namespace test_runner |