| // Licensed to the Software Freedom Conservancy (SFC) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The SFC licenses this file |
| // to you under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "SendMessageActionSimulator.h" |
| |
| #include <assert.h> |
| #include <math.h> |
| |
| #include "errorcodes.h" |
| #include "logging.h" |
| |
| #include "../DocumentHost.h" |
| #include "../HookProcessor.h" |
| #include "../WindowUtilities.h" |
| |
| namespace webdriver { |
| |
| SendMessageActionSimulator::SendMessageActionSimulator() { |
| this->keyboard_state_buffer_.resize(256); |
| ::ZeroMemory(&this->keyboard_state_buffer_[0], |
| this->keyboard_state_buffer_.size()); |
| } |
| |
| SendMessageActionSimulator::~SendMessageActionSimulator() { |
| } |
| |
| int SendMessageActionSimulator::SimulateActions(BrowserHandle browser_wrapper, |
| std::vector<INPUT> inputs, |
| InputState* input_state) { |
| LOG(TRACE) << "Entering InputManager::PerformInputWithSendMessage"; |
| HWND window_handle = browser_wrapper->GetContentWindowHandle(); |
| |
| HookProcessor message_processor; |
| message_processor.Initialize("GetMessageProc", WH_GETMESSAGE); |
| if (!message_processor.CanSetWindowsHook(window_handle)) { |
| LOG(WARN) << "Keystrokes may be slow! There is a mismatch in the " |
| << "bitness between the driver and browser. In particular, " |
| << "be sure you are not attempting to use a 64-bit " |
| << "IEDriverServer.exe against IE 10 or 11, even on 64-bit " |
| << "Windows."; |
| } |
| |
| DWORD browser_thread_id = ::GetWindowThreadProcessId(window_handle, NULL); |
| DWORD current_thread_id = ::GetCurrentThreadId(); |
| BOOL attached = ::AttachThreadInput(current_thread_id, browser_thread_id, TRUE); |
| |
| HKL layout = GetKeyboardLayout(browser_thread_id); |
| |
| int double_click_time = ::GetDoubleClickTime(); |
| |
| std::vector<INPUT>::const_iterator input_iterator = inputs.begin(); |
| for (; input_iterator != inputs.end(); ++input_iterator) { |
| INPUT current_input = *input_iterator; |
| if (current_input.type == INPUT_MOUSE) { |
| if (current_input.mi.dwFlags & MOUSEEVENTF_MOVE) { |
| this->SendMouseMoveMessage(window_handle, |
| *input_state, |
| current_input.mi.dx, |
| current_input.mi.dy); |
| } else if (current_input.mi.dwFlags & MOUSEEVENTF_LEFTDOWN) { |
| bool is_double_click = this->IsInputDoubleClick(current_input, |
| *input_state); |
| this->SendMouseDownMessage(window_handle, |
| *input_state, |
| WD_CLIENT_LEFT_MOUSE_BUTTON, |
| current_input.mi.dx, |
| current_input.mi.dy, |
| is_double_click); |
| } else if (current_input.mi.dwFlags & MOUSEEVENTF_LEFTUP) { |
| this->SendMouseUpMessage(window_handle, |
| *input_state, |
| WD_CLIENT_LEFT_MOUSE_BUTTON, |
| current_input.mi.dx, |
| current_input.mi.dy); |
| } else if (current_input.mi.dwFlags & MOUSEEVENTF_RIGHTDOWN) { |
| bool is_double_click = this->IsInputDoubleClick(current_input, |
| *input_state); |
| this->SendMouseDownMessage(window_handle, |
| *input_state, |
| WD_CLIENT_RIGHT_MOUSE_BUTTON, |
| current_input.mi.dx, |
| current_input.mi.dy, |
| is_double_click); |
| } else if (current_input.mi.dwFlags & MOUSEEVENTF_RIGHTUP) { |
| this->SendMouseUpMessage(window_handle, |
| *input_state, |
| WD_CLIENT_RIGHT_MOUSE_BUTTON, |
| current_input.mi.dx, |
| current_input.mi.dy); |
| } |
| } else if (current_input.type == INPUT_KEYBOARD) { |
| bool unicode = (current_input.ki.dwFlags & KEYEVENTF_UNICODE) != 0; |
| bool extended = (current_input.ki.dwFlags & KEYEVENTF_EXTENDEDKEY) != 0; |
| if (current_input.ki.dwFlags & KEYEVENTF_KEYUP) { |
| this->SendKeyUpMessage(window_handle, |
| *input_state, |
| current_input.ki.wVk, |
| current_input.ki.wScan, |
| extended, |
| unicode, |
| layout, |
| &this->keyboard_state_buffer_); |
| } else { |
| this->SendKeyDownMessage(window_handle, |
| *input_state, |
| current_input.ki.wVk, |
| current_input.ki.wScan, |
| extended, |
| unicode, |
| layout, |
| &this->keyboard_state_buffer_); |
| } |
| } else if (current_input.type == INPUT_HARDWARE) { |
| ::Sleep(current_input.hi.uMsg); |
| } |
| this->UpdateInputState(current_input, input_state); |
| } |
| attached = ::AttachThreadInput(current_thread_id, browser_thread_id, FALSE); |
| message_processor.Dispose(); |
| return WD_SUCCESS; |
| } |
| |
| bool SendMessageActionSimulator::IsInputDoubleClick(INPUT current_input, |
| InputState input_state) { |
| DWORD double_click_time = ::GetDoubleClickTime(); |
| unsigned int time_since_last_click = static_cast<unsigned int>(static_cast<float>(clock() - input_state.last_click_time) / CLOCKS_PER_SEC * 1000); |
| bool button_pressed = true; |
| if ((current_input.mi.dwFlags & MOUSEEVENTF_LEFTDOWN) != 0) { |
| button_pressed = input_state.is_left_button_pressed; |
| } |
| |
| if ((current_input.mi.dwFlags & MOUSEEVENTF_RIGHTDOWN) != 0) { |
| button_pressed = input_state.is_right_button_pressed; |
| } |
| |
| if (!button_pressed && |
| input_state.mouse_x == current_input.mi.dx && |
| input_state.mouse_y == current_input.mi.dy && |
| time_since_last_click < double_click_time) { |
| return true; |
| } |
| return false; |
| } |
| |
| void SendMessageActionSimulator::SendKeyDownMessage(HWND window_handle, |
| InputState input_state, |
| int key_code, |
| int scan_code, |
| bool extended, |
| bool unicode, |
| HKL layout, |
| std::vector<BYTE>* keyboard_state) { |
| LPARAM lparam = 0; |
| clock_t max_wait = clock() + 250; |
| |
| if (key_code == VK_SHIFT || key_code == VK_CONTROL || key_code == VK_MENU) { |
| (*keyboard_state)[key_code] |= 0x80; |
| |
| lparam = 1 | ::MapVirtualKeyEx(key_code, 0, layout) << 16; |
| if (!::PostMessage(window_handle, WM_KEYDOWN, key_code, lparam)) { |
| LOG(WARN) << "Modifier keydown failed: " << ::GetLastError(); |
| } |
| |
| WindowUtilities::Wait(0); |
| return; |
| } |
| |
| if (unicode) { |
| wchar_t c = static_cast<wchar_t>(scan_code); |
| SHORT keyscan = VkKeyScanW(c); |
| HookProcessor::ResetEventCount(); |
| ::PostMessage(window_handle, WM_KEYDOWN, keyscan, lparam); |
| ::PostMessage(window_handle, WM_USER, 1234, 5678); |
| WindowUtilities::Wait(0); |
| bool is_processed = HookProcessor::GetEventCount() > 0; |
| while (!is_processed && clock() < max_wait) { |
| WindowUtilities::Wait(5); |
| is_processed = HookProcessor::GetEventCount() > 0; |
| } |
| ::PostMessage(window_handle, WM_CHAR, c, lparam); |
| WindowUtilities::Wait(0); |
| } else { |
| key_code = LOBYTE(key_code); |
| (*keyboard_state)[key_code] |= 0x80; |
| ::SetKeyboardState(&((*keyboard_state)[0])); |
| |
| lparam = 1 | scan_code << 16; |
| if (extended) { |
| lparam |= 1 << 24; |
| } |
| |
| HookProcessor::ResetEventCount(); |
| if (!::PostMessage(window_handle, WM_KEYDOWN, key_code, lparam)) { |
| LOG(WARN) << "Key down failed: " << ::GetLastError(); |
| } |
| |
| ::PostMessage(window_handle, WM_USER, 1234, 5678); |
| |
| // Listen out for the keypress event which IE synthesizes when IE |
| // processes the keydown message. Use a time out, just in case we |
| // have not got the logic right :) |
| |
| bool is_processed = HookProcessor::GetEventCount() > 0; |
| max_wait = clock() + 5000; |
| while (!is_processed && clock() < max_wait) { |
| WindowUtilities::Wait(5); |
| is_processed = HookProcessor::GetEventCount() > 0; |
| if (clock() >= max_wait) { |
| LOG(WARN) << "Timeout awaiting keypress: " << key_code; |
| break; |
| } |
| } |
| } |
| } |
| |
| void SendMessageActionSimulator::SendKeyUpMessage(HWND window_handle, |
| InputState input_state, |
| int key_code, |
| int scan_code, |
| bool extended, |
| bool unicode, |
| HKL layout, |
| std::vector<BYTE>* keyboard_state) { |
| LPARAM lparam = 0; |
| |
| if (key_code == VK_SHIFT || key_code == VK_CONTROL || key_code == VK_MENU) { |
| (*keyboard_state)[key_code] &= ~0x80; |
| |
| lparam = 1 | ::MapVirtualKeyEx(key_code, 0, layout) << 16; |
| lparam |= 0x3 << 30; |
| if (!::PostMessage(window_handle, WM_KEYUP, key_code, lparam)) { |
| LOG(WARN) << "Modifier keyup failed: " << ::GetLastError(); |
| } |
| |
| WindowUtilities::Wait(0); |
| return; |
| } |
| |
| if (unicode) { |
| wchar_t c = static_cast<wchar_t>(scan_code); |
| SHORT keyscan = VkKeyScanW(c); |
| ::PostMessage(window_handle, WM_KEYUP, keyscan, lparam); |
| } else { |
| key_code = LOBYTE(key_code); |
| (*keyboard_state)[key_code] &= ~0x80; |
| ::SetKeyboardState(&((*keyboard_state)[0])); |
| |
| lparam = 1 | scan_code << 16; |
| if (extended) { |
| lparam |= 1 << 24; |
| } |
| |
| lparam |= 0x3 << 30; |
| if (!::PostMessage(window_handle, WM_KEYUP, key_code, lparam)) { |
| LOG(WARN) << "Key up failed: " << ::GetLastError(); |
| } |
| |
| WindowUtilities::Wait(0); |
| } |
| } |
| |
| void SendMessageActionSimulator::SendMouseMoveMessage(HWND window_handle, |
| InputState input_state, |
| int x, |
| int y) { |
| LRESULT message_timeout = 0; |
| DWORD_PTR send_message_result = 0; |
| WPARAM button_value = 0; |
| if (input_state.is_left_button_pressed) { |
| button_value |= MK_LBUTTON; |
| } |
| if (input_state.is_right_button_pressed) { |
| button_value |= MK_RBUTTON; |
| } |
| if (input_state.is_shift_pressed) { |
| button_value |= MK_SHIFT; |
| } |
| if (input_state.is_control_pressed) { |
| button_value |= MK_CONTROL; |
| } |
| LPARAM coordinates = MAKELPARAM(x, y); |
| message_timeout = ::SendMessageTimeout(window_handle, |
| WM_MOUSEMOVE, |
| button_value, |
| coordinates, |
| SMTO_NORMAL, |
| 100, |
| &send_message_result); |
| if (message_timeout == 0) { |
| LOGERR(WARN) << "MouseMove: SendMessageTimeout failed"; |
| } |
| } |
| |
| void SendMessageActionSimulator::SendMouseDownMessage(HWND window_handle, |
| InputState input_state, |
| int button, |
| int x, |
| int y, |
| bool is_double_click) { |
| UINT msg = WM_LBUTTONDOWN; |
| WPARAM button_value = MK_LBUTTON; |
| if (is_double_click) { |
| msg = WM_LBUTTONDBLCLK; |
| } |
| if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) { |
| msg = WM_RBUTTONDOWN; |
| button_value = MK_RBUTTON; |
| if (is_double_click) { |
| msg = WM_RBUTTONDBLCLK; |
| } |
| } |
| int modifier = 0; |
| if (input_state.is_shift_pressed) { |
| modifier |= MK_SHIFT; |
| } |
| if (input_state.is_control_pressed) { |
| modifier |= MK_CONTROL; |
| } |
| button_value |= modifier; |
| LPARAM coordinates = MAKELPARAM(x, y); |
| // Must use PostMessage for mouse down because message gets lost with |
| // SendMessage and variants. Use a SendMessage with WM_USER to ensure |
| // the posted message has been processed. |
| ::PostMessage(window_handle, msg, button_value, coordinates); |
| ::SendMessage(window_handle, WM_USER, 0, 0); |
| |
| // This 5 millisecond sleep is important for the click element scenario, |
| // as it allows the element to register and respond to the focus event. |
| ::Sleep(5); |
| } |
| |
| |
| void SendMessageActionSimulator::SendMouseUpMessage(HWND window_handle, |
| InputState input_state, |
| int button, |
| int x, |
| int y) { |
| UINT msg = WM_LBUTTONUP; |
| WPARAM button_value = MK_LBUTTON; |
| if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) { |
| msg = WM_RBUTTONUP; |
| button_value = MK_RBUTTON; |
| } |
| int modifier = 0; |
| if (input_state.is_shift_pressed) { |
| modifier |= MK_SHIFT; |
| } |
| if (input_state.is_control_pressed) { |
| modifier |= MK_CONTROL; |
| } |
| button_value |= modifier; |
| LPARAM coordinates = MAKELPARAM(x, y); |
| // To properly mimic manual mouse movement, we need a move before the up. |
| ::SendMessage(window_handle, WM_MOUSEMOVE, modifier, coordinates); |
| // Must use PostMessage for mouse up because message gets lost with |
| // SendMessage and variants. Use a SendMessage with WM_USER to ensure |
| // the posted message has been processed. |
| ::PostMessage(window_handle, msg, button_value, coordinates); |
| ::SendMessage(window_handle, WM_USER, 0, 0); |
| } |
| |
| } // namespace webdriver |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| LRESULT CALLBACK GetMessageProc(int nCode, WPARAM wParam, LPARAM lParam) { |
| if ((nCode == HC_ACTION) && (wParam == PM_REMOVE)) { |
| MSG* msg = reinterpret_cast<MSG*>(lParam); |
| if (msg->message == WM_USER && msg->wParam == 1234 && msg->lParam == 5678) { |
| int message_count = 50; |
| webdriver::HookProcessor::IncrementEventCount(message_count); |
| } |
| } |
| |
| return CallNextHookEx(NULL, nCode, wParam, lParam); |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |
