| // 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 "SendKeysCommandHandler.h" | |
| #include <ctime> | |
| #include <iomanip> | |
| #include <UIAutomation.h> | |
| #include "errorcodes.h" | |
| #include "keycodes.h" | |
| #include "logging.h" | |
| #include "../Browser.h" | |
| #include "../BrowserFactory.h" | |
| #include "../Element.h" | |
| #include "../IECommandExecutor.h" | |
| #include "../InputManager.h" | |
| #include "../StringUtilities.h" | |
| #include "../VariantUtilities.h" | |
| #include "../WindowUtilities.h" | |
| #define MAXIMUM_DIALOG_FIND_RETRIES 50 | |
| #define MAXIMUM_CONTROL_FIND_RETRIES 10 | |
| const LPCTSTR fileDialogNames[] = { | |
| _T("#32770"), | |
| _T("ComboBoxEx32"), | |
| _T("ComboBox"), | |
| _T("Edit"), | |
| NULL | |
| }; | |
| namespace webdriver { | |
| std::wstring SendKeysCommandHandler::error_text = L""; | |
| struct DialogParentWindowInfo { | |
| DWORD process_id; | |
| const wchar_t* class_name; | |
| HWND window_handle; | |
| }; | |
| SendKeysCommandHandler::SendKeysCommandHandler(void) { | |
| } | |
| SendKeysCommandHandler::~SendKeysCommandHandler(void) { | |
| } | |
| void SendKeysCommandHandler::ExecuteInternal( | |
| const IECommandExecutor& executor, | |
| const ParametersMap& command_parameters, | |
| Response* response) { | |
| ParametersMap::const_iterator id_parameter_iterator = command_parameters.find("id"); | |
| ParametersMap::const_iterator value_parameter_iterator = command_parameters.find("text"); | |
| if (id_parameter_iterator == command_parameters.end()) { | |
| response->SetErrorResponse(400, "Missing parameter in URL: id"); | |
| return; | |
| } else if (value_parameter_iterator == command_parameters.end()) { | |
| response->SetErrorResponse(400, "Missing parameter: text"); | |
| return; | |
| } else { | |
| std::string element_id = id_parameter_iterator->second.asString(); | |
| if (!value_parameter_iterator->second.isString()) { | |
| response->SetErrorResponse(ERROR_INVALID_ARGUMENT, "parameter 'text' must be a string"); | |
| return; | |
| } | |
| std::wstring keys = StringUtilities::ToWString(value_parameter_iterator->second.asString()); | |
| BrowserHandle browser_wrapper; | |
| int status_code = executor.GetCurrentBrowser(&browser_wrapper); | |
| if (status_code != WD_SUCCESS) { | |
| response->SetErrorResponse(status_code, "Unable to get browser"); | |
| return; | |
| } | |
| ElementHandle initial_element; | |
| status_code = this->GetElement(executor, element_id, &initial_element); | |
| if (status_code == WD_SUCCESS) { | |
| ElementHandle element_wrapper = initial_element; | |
| CComPtr<IHTMLOptionElement> option; | |
| HRESULT hr = initial_element->element()->QueryInterface<IHTMLOptionElement>(&option); | |
| if (SUCCEEDED(hr) && option) { | |
| // If this is an <option> element, we want to operate on its parent | |
| // <select> element. | |
| CComPtr<IHTMLElement> parent_node; | |
| hr = initial_element->element()->get_parentElement(&parent_node); | |
| while (SUCCEEDED(hr) && parent_node) { | |
| CComPtr<IHTMLSelectElement> select; | |
| HRESULT select_hr = parent_node->QueryInterface<IHTMLSelectElement>(&select); | |
| if (SUCCEEDED(select_hr) && select) { | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| mutable_executor.AddManagedElement(parent_node, &element_wrapper); | |
| break; | |
| } | |
| hr = parent_node->get_parentElement(&parent_node); | |
| } | |
| } | |
| // Scroll the target element into view before executing the action | |
| // sequence. | |
| LocationInfo location = {}; | |
| std::vector<LocationInfo> frame_locations; | |
| element_wrapper->GetLocationOnceScrolledIntoView(executor.input_manager()->scroll_behavior(), | |
| &location, | |
| &frame_locations); | |
| if (this->IsFileUploadElement(element_wrapper)) { | |
| if (executor.use_strict_file_interactability()) { | |
| std::string upload_error_description = ""; | |
| if (!this->IsElementInteractable(element_wrapper, | |
| &upload_error_description)) { | |
| response->SetErrorResponse(ERROR_ELEMENT_NOT_INTERACTABLE, | |
| upload_error_description); | |
| return; | |
| } | |
| } | |
| this->UploadFile(browser_wrapper, element_wrapper, executor, keys, response); | |
| return; | |
| } | |
| std::string error_description = ""; | |
| bool is_interactable = IsElementInteractable(element_wrapper, | |
| &error_description); | |
| if (!is_interactable) { | |
| response->SetErrorResponse(ERROR_ELEMENT_NOT_INTERACTABLE, | |
| error_description); | |
| return; | |
| } | |
| if (!this->VerifyPageHasFocus(browser_wrapper)) { | |
| LOG(WARN) << "HTML rendering pane does not have the focus. Keystrokes may go to an unexpected UI element."; | |
| } | |
| if (!this->WaitUntilElementFocused(element_wrapper)) { | |
| error_description = "Element cannot be interacted with via the keyboard because it is not focusable"; | |
| response->SetErrorResponse(ERROR_ELEMENT_NOT_INTERACTABLE, | |
| error_description); | |
| return; | |
| } | |
| Json::Value actions = this->CreateActionSequencePayload(executor, &keys); | |
| std::string error_info = ""; | |
| status_code = executor.input_manager()->PerformInputSequence(browser_wrapper, actions, &error_info); | |
| response->SetSuccessResponse(Json::Value::null); | |
| return; | |
| } else { | |
| response->SetErrorResponse(status_code, "Element is no longer valid"); | |
| return; | |
| } | |
| } | |
| } | |
| bool SendKeysCommandHandler::IsElementInteractable(ElementHandle element_wrapper, | |
| std::string* error_description) { | |
| bool displayed; | |
| int status_code = element_wrapper->IsDisplayed(true, &displayed); | |
| if (status_code != WD_SUCCESS || !displayed) { | |
| *error_description = "Element cannot be interacted with via the keyboard because it is not displayed"; | |
| return false; | |
| } | |
| if (!element_wrapper->IsEnabled()) { | |
| *error_description = "Element cannot be interacted with via the keyboard because it is not enabled"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| Json::Value SendKeysCommandHandler::CreateActionSequencePayload(const IECommandExecutor& executor, | |
| std::wstring* keys) { | |
| bool shift_pressed = executor.input_manager()->is_shift_pressed(); | |
| bool control_pressed = executor.input_manager()->is_control_pressed(); | |
| bool alt_pressed = executor.input_manager()->is_alt_pressed(); | |
| keys->push_back(static_cast<wchar_t>(WD_KEY_NULL)); | |
| Json::Value key_array(Json::arrayValue); | |
| for (size_t i = 0; i < keys->size(); ++i) { | |
| std::wstring character = L""; | |
| character.push_back(keys->at(i)); | |
| if (IS_HIGH_SURROGATE(keys->at(i))) { | |
| // We've converted the key string to a wstring, which contain | |
| // wchar_t elements. On Windows, wchar_t is 16 bits, meaning | |
| // the string has been encoded to UTF-16, which implies each | |
| // Unicode code point will be either one wchar_t (where the | |
| // value <= 0xFFFF), or two wchar_ts (where the code point is | |
| // represented by a surrogate pair). In the latter case, we | |
| // test for the first part of a surrogate pair, and if it is | |
| // one, we grab the next wchar_t, and use the two together to | |
| // represent a single Unicode "character." | |
| ++i; | |
| character.push_back(keys->at(i)); | |
| } | |
| std::string single_key = StringUtilities::ToString(character); | |
| if (keys->at(i) == WD_KEY_SHIFT) { | |
| Json::Value shift_key_value; | |
| shift_key_value["value"] = single_key; | |
| if (shift_pressed) { | |
| shift_key_value["type"] = "keyUp"; | |
| } else { | |
| shift_key_value["type"] = "keyDown"; | |
| shift_pressed = true; | |
| } | |
| key_array.append(shift_key_value); | |
| continue; | |
| } else if (keys->at(i) == WD_KEY_CONTROL) { | |
| Json::Value control_key_value; | |
| control_key_value["value"] = single_key; | |
| if (control_pressed) { | |
| control_key_value["type"] = "keyUp"; | |
| } else { | |
| control_key_value["type"] = "keyDown"; | |
| control_pressed = true; | |
| } | |
| key_array.append(control_key_value); | |
| continue; | |
| } else if (keys->at(i) == WD_KEY_ALT) { | |
| Json::Value alt_key_value; | |
| alt_key_value["value"] = single_key; | |
| if (alt_pressed) { | |
| alt_key_value["type"] = "keyUp"; | |
| } else { | |
| alt_key_value["type"] = "keyDown"; | |
| alt_pressed = true; | |
| } | |
| key_array.append(alt_key_value); | |
| continue; | |
| } | |
| Json::Value key_down_value; | |
| key_down_value["type"] = "keyDown"; | |
| key_down_value["value"] = single_key; | |
| key_array.append(key_down_value); | |
| Json::Value key_up_value; | |
| key_up_value["type"] = "keyUp"; | |
| key_up_value["value"] = single_key; | |
| key_array.append(key_up_value); | |
| } | |
| Json::Value value; | |
| value["type"] = "key"; | |
| value["id"] = "send keys keyboard"; | |
| value["actions"] = key_array; | |
| Json::Value actions(Json::arrayValue); | |
| actions.append(value); | |
| return actions; | |
| } | |
| bool SendKeysCommandHandler::HasMultipleAttribute(ElementHandle element_wrapper) { | |
| bool allows_multiple = false; | |
| CComVariant multiple_value; | |
| int status_code = element_wrapper->GetAttributeValue("multiple", | |
| &multiple_value); | |
| if (status_code == WD_SUCCESS && | |
| VariantUtilities::VariantIsString(multiple_value)) { | |
| if (0 == wcscmp(multiple_value.bstrVal, L"true")) { | |
| allows_multiple = true; | |
| } | |
| } | |
| return allows_multiple; | |
| } | |
| void SendKeysCommandHandler::UploadFile(BrowserHandle browser_wrapper, | |
| ElementHandle element_wrapper, | |
| const IECommandExecutor& executor, | |
| const std::wstring& keys, | |
| Response* response) { | |
| bool allows_multiple = this->HasMultipleAttribute(element_wrapper); | |
| std::vector<std::wstring> file_list; | |
| StringUtilities::Split(keys, L"\n", &file_list); | |
| if (file_list.size() == 0) { | |
| response->SetErrorResponse(EINVALIDARGUMENT, | |
| "Upload file cannot be an empty string."); | |
| return; | |
| } | |
| if (!allows_multiple && file_list.size() > 1) { | |
| response->SetErrorResponse(EINVALIDARGUMENT, | |
| "Attempting to upload multiple files to file upload element without multiple attribute."); | |
| return; | |
| } | |
| std::wstring file_directory = L""; | |
| std::wstring file_dialog_keys = L""; | |
| std::vector<std::wstring>::const_iterator iterator = file_list.begin(); | |
| for (; iterator < file_list.end(); ++iterator) { | |
| std::wstring file_name = *iterator; | |
| // Key sequence should be a path and file name. Check | |
| // to see that the file exists before invoking the file | |
| // selection dialog. Note that we also error if the file | |
| // path passed in is valid, but is a directory instead of | |
| // a file. | |
| bool path_exists = ::PathFileExists(file_name.c_str()) == TRUE; | |
| if (!path_exists) { | |
| response->SetErrorResponse(EINVALIDARGUMENT, | |
| "Attempting to upload file '" + StringUtilities::ToString(file_name) + "' which does not exist."); | |
| return; | |
| } | |
| bool path_is_directory = ::PathIsDirectory(file_name.c_str()) == TRUE; | |
| if (path_is_directory) { | |
| response->SetErrorResponse(EINVALIDARGUMENT, | |
| "Attempting to upload file '" + StringUtilities::ToString(file_name) + "' which is a directory."); | |
| return; | |
| } | |
| if (allows_multiple) { | |
| std::vector<wchar_t> file_name_buffer; | |
| StringUtilities::ToBuffer(file_name, &file_name_buffer); | |
| ::PathRemoveFileSpec(&file_name_buffer[0]); | |
| std::wstring current_file_directory = &file_name_buffer[0]; | |
| if (file_directory.size() == 0) { | |
| file_directory = current_file_directory; | |
| } | |
| if (file_directory != current_file_directory) { | |
| response->SetErrorResponse(EINVALIDARGUMENT, | |
| "Attempting to upload multiple files, but all files must be in the same directory."); | |
| return; | |
| } | |
| } | |
| if (allows_multiple && file_dialog_keys.size() > 0) { | |
| file_dialog_keys.append(L" "); | |
| } | |
| if (allows_multiple && file_name.at(0) != L'\"') { | |
| file_dialog_keys.append(L"\""); | |
| } | |
| file_dialog_keys.append(file_name); | |
| if (allows_multiple && file_name.at(file_name.size() - 1) != L'\"') { | |
| file_dialog_keys.append(L"\""); | |
| } | |
| } | |
| HWND window_handle = browser_wrapper->GetContentWindowHandle(); | |
| HWND top_level_window_handle = browser_wrapper->GetTopLevelWindowHandle(); | |
| DWORD ie_process_id; | |
| ::GetWindowThreadProcessId(window_handle, &ie_process_id); | |
| FileNameData key_data; | |
| key_data.main = top_level_window_handle; | |
| key_data.hwnd = window_handle; | |
| key_data.text = file_dialog_keys.c_str(); | |
| key_data.ieProcId = ie_process_id; | |
| key_data.dialogTimeout = executor.file_upload_dialog_timeout(); | |
| key_data.useLegacyDialogHandling = executor.use_legacy_file_upload_dialog_handling(); | |
| unsigned int thread_id; | |
| HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL, | |
| 0, | |
| &SendKeysCommandHandler::SetFileValue, | |
| reinterpret_cast<void*>(&key_data), | |
| 0, | |
| &thread_id)); | |
| LOG(DEBUG) << "Clicking upload button and starting to handle file selection dialog"; | |
| element_wrapper->element()->click(); | |
| // We're now blocked until the dialog closes. | |
| ::CloseHandle(thread_handle); | |
| response->SetSuccessResponse(Json::Value::null); | |
| } | |
| bool SendKeysCommandHandler::IsFileUploadElement(ElementHandle element_wrapper) { | |
| CComPtr<IHTMLElement> element(element_wrapper->element()); | |
| CComPtr<IHTMLInputFileElement> file; | |
| element->QueryInterface<IHTMLInputFileElement>(&file); | |
| CComPtr<IHTMLInputElement> input; | |
| element->QueryInterface<IHTMLInputElement>(&input); | |
| CComBSTR element_type; | |
| if (input) { | |
| input->get_type(&element_type); | |
| HRESULT hr = element_type.ToLower(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed converting type attribute of <input> element to lowercase using ToLower() method of BSTR"; | |
| } | |
| } | |
| bool is_file_element = (file != NULL) || | |
| (input != NULL && element_type == L"file"); | |
| return is_file_element; | |
| } | |
| bool SendKeysCommandHandler::GetFileSelectionDialogCandidates(std::vector<HWND> parent_window_handles, IUIAutomation* ui_automation, IUIAutomationElementArray** dialog_candidates) { | |
| LOG(INFO) << "using " << parent_window_handles.size() << " parent windows"; | |
| CComVariant dialog_control_type(UIA_WindowControlTypeId); | |
| CComPtr<IUIAutomationCondition> dialog_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_ControlTypePropertyId, | |
| dialog_control_type, | |
| &dialog_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for dialog"; | |
| return false; | |
| } | |
| bool found_candidate_dialogs = false; | |
| int window_array_length = 0; | |
| std::vector<HWND>::const_iterator handle_iterator = parent_window_handles.begin(); | |
| for (; handle_iterator != parent_window_handles.end(); ++handle_iterator) { | |
| CComPtr<IUIAutomationElement> parent_window; | |
| hr = ui_automation->ElementFromHandle(*handle_iterator, &parent_window); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Did not get parent window UI Automation object"; | |
| continue; | |
| } | |
| CComPtr<IUIAutomationElementArray> current_dialog_candidates; | |
| hr = parent_window->FindAll(TreeScope::TreeScope_Children, | |
| dialog_condition, | |
| ¤t_dialog_candidates); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Process of finding child dialogs of parent window failed"; | |
| continue; | |
| } | |
| if (!current_dialog_candidates) { | |
| LOGHR(WARN, hr) << "Found no dialogs as children of parent window (null candidates)"; | |
| continue; | |
| } | |
| hr = current_dialog_candidates->get_Length(&window_array_length); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not get length of list of child dialogs of parent window"; | |
| continue; | |
| } | |
| if (window_array_length == 0) { | |
| LOG(WARN) << "Found no dialogs as children of parent window (empty candidates)"; | |
| continue; | |
| } else { | |
| // Use CComPtr::CopyTo() to increment the refcount, because when the | |
| // current dialog candidates pointer goes out of scope, it will decrement | |
| // the refcount, which will free the object when the refcount equals | |
| // zero. | |
| LOG(INFO) << "Found " << window_array_length << "children"; | |
| current_dialog_candidates.CopyTo(dialog_candidates); | |
| found_candidate_dialogs = true; | |
| break; | |
| } | |
| } | |
| return found_candidate_dialogs; | |
| } | |
| bool SendKeysCommandHandler::FillFileName(const wchar_t* file_name, | |
| IUIAutomation* ui_automation, | |
| IUIAutomationElement* file_selection_dialog) { | |
| CComVariant file_name_combo_box_automation_id(L"1148"); | |
| CComPtr<IUIAutomationCondition> file_name_combo_box_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId, | |
| file_name_combo_box_automation_id, | |
| &file_name_combo_box_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for file selection combo box"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> file_name_combo_box; | |
| hr = file_selection_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| file_name_combo_box_condition, | |
| &file_name_combo_box); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get file name combo box on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| CComVariant edit_control_type(UIA_EditControlTypeId); | |
| CComPtr<IUIAutomationCondition> file_name_edit_condition; | |
| hr = ui_automation->CreatePropertyCondition(UIA_ControlTypePropertyId, | |
| edit_control_type, | |
| &file_name_edit_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for file selection edit control"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> file_name_edit_box; | |
| hr = file_name_combo_box->FindFirst(TreeScope::TreeScope_Children, | |
| file_name_edit_condition, | |
| &file_name_edit_box); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get file name edit box from combo box on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationValuePattern> file_name_value_pattern; | |
| hr = file_name_edit_box->GetCurrentPatternAs(UIA_ValuePatternId, | |
| IID_PPV_ARGS(&file_name_value_pattern)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get value pattern for file name edit box on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| CComBSTR file_name_bstr(file_name); | |
| hr = file_name_value_pattern->SetValue(file_name_bstr); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get set file name on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool SendKeysCommandHandler::AcceptFileSelection(IUIAutomation* ui_automation, | |
| IUIAutomationElement* file_selection_dialog) { | |
| CComVariant open_button_automation_id(L"1"); | |
| CComPtr<IUIAutomationCondition> open_button_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId, | |
| open_button_automation_id, | |
| &open_button_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for open button"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> open_button; | |
| hr = file_selection_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| open_button_condition, | |
| &open_button); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get open button on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationInvokePattern> open_button_invoke_pattern; | |
| hr = open_button->GetCurrentPatternAs(UIA_InvokePatternId, | |
| IID_PPV_ARGS(&open_button_invoke_pattern)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get invoke pattern for open button on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| hr = open_button_invoke_pattern->Invoke(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to click open button on current dialog, trying next dialog"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool SendKeysCommandHandler::WaitForFileSelectionDialogClose(const int timeout, | |
| IUIAutomationElement* file_selection_dialog) { | |
| HWND dialog_window_handle; | |
| HRESULT hr = file_selection_dialog->get_CurrentNativeWindowHandle(reinterpret_cast<UIA_HWND*>(&dialog_window_handle)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not get window handle for file selection dialog"; | |
| return false; | |
| } | |
| int max_retries = timeout / 100; | |
| bool is_dialog_closed = ::IsWindow(dialog_window_handle) == FALSE; | |
| while (!is_dialog_closed && --max_retries) { | |
| ::Sleep(100); | |
| is_dialog_closed = ::IsWindow(dialog_window_handle) == FALSE; | |
| } | |
| return is_dialog_closed; | |
| } | |
| bool SendKeysCommandHandler::FindFileSelectionErrorDialog(IUIAutomation* ui_automation, | |
| IUIAutomationElement* file_selection_dialog, | |
| IUIAutomationElement** error_dialog) { | |
| CComVariant dialog_control_type(UIA_WindowControlTypeId); | |
| CComPtr<IUIAutomationCondition> dialog_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_ControlTypePropertyId, | |
| dialog_control_type, | |
| &dialog_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for dialog"; | |
| return false; | |
| } | |
| hr = file_selection_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| dialog_condition, | |
| error_dialog); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not find error dialog owned by file selection dialog"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool SendKeysCommandHandler::DismissFileSelectionErrorDialog(IUIAutomation* ui_automation, | |
| IUIAutomationElement* error_dialog) { | |
| CComVariant error_dialog_text_automation_id(L"ContentText"); | |
| CComPtr<IUIAutomationCondition> error_dialog_text_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId, | |
| error_dialog_text_automation_id, | |
| &error_dialog_text_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for error text control"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> error_dialog_text_control; | |
| hr = error_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| error_dialog_text_condition, | |
| &error_dialog_text_control); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get error message text control on error dialog"; | |
| } | |
| CComBSTR error_dialog_text; | |
| hr = error_dialog_text_control->get_CurrentName(&error_dialog_text); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get error message text from text control on error dialog"; | |
| } | |
| error_text = error_dialog_text; | |
| CComVariant error_dialog_ok_button_automation_id(L"CommandButton_1"); | |
| CComPtr<IUIAutomationCondition> error_dialog_ok_button_condition; | |
| hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId, | |
| error_dialog_ok_button_automation_id, | |
| &error_dialog_ok_button_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for error message OK button"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> error_dialog_ok_button; | |
| hr = error_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| error_dialog_ok_button_condition, | |
| &error_dialog_ok_button); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get OK button on error dialog"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationInvokePattern> error_dialog_ok_button_invoke_pattern; | |
| hr = error_dialog_ok_button->GetCurrentPatternAs(UIA_InvokePatternId, | |
| IID_PPV_ARGS(&error_dialog_ok_button_invoke_pattern)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get invoke pattern for OK button on error dialog"; | |
| return false; | |
| } | |
| hr = error_dialog_ok_button_invoke_pattern->Invoke(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to click OK button on error dialog"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool SendKeysCommandHandler::DismissFileSelectionDialog(IUIAutomation* ui_automation, | |
| IUIAutomationElement* file_selection_dialog) { | |
| CComVariant cancel_button_automation_id(L"2"); | |
| CComPtr<IUIAutomationCondition> cancel_button_condition; | |
| HRESULT hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId, | |
| cancel_button_automation_id, | |
| &cancel_button_condition); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Could not create condition to look for cancel button"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationElement> cancel_button; | |
| hr = file_selection_dialog->FindFirst(TreeScope::TreeScope_Children, | |
| cancel_button_condition, | |
| &cancel_button); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get cancel button on current dialog"; | |
| return false; | |
| } | |
| CComPtr<IUIAutomationInvokePattern> cancel_button_invoke_pattern; | |
| hr = cancel_button->GetCurrentPatternAs(UIA_InvokePatternId, | |
| IID_PPV_ARGS(&cancel_button_invoke_pattern)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get invoke pattern for cancel button on current dialog"; | |
| return false; | |
| } | |
| hr = cancel_button_invoke_pattern->Invoke(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to cancel file selection dialog"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| std::vector<HWND> SendKeysCommandHandler::FindWindowCandidates(FileNameData* file_data) { | |
| // Find a dialog parent window with a class name of "Alternate | |
| // Modal Top Most" belonging to the same process as the IE | |
| // content process. If we find one, add it to the list of | |
| // window handles that might be the file selection dialog's | |
| // direct parent. | |
| DialogParentWindowInfo window_info; | |
| window_info.process_id = file_data->ieProcId; | |
| window_info.class_name = L"Alternate Modal Top Most"; | |
| window_info.window_handle = NULL; | |
| ::EnumWindows(&SendKeysCommandHandler::FindWindowWithClassNameAndProcess, | |
| reinterpret_cast<LPARAM>(&window_info)); | |
| std::vector<HWND> window_handles; | |
| if (window_info.window_handle != NULL) { | |
| LOG(INFO) << "found \"" << window_info.class_name << "\" " << window_info.window_handle; | |
| window_handles.push_back(window_info.window_handle); | |
| } | |
| window_handles.push_back(file_data->main); | |
| return window_handles; | |
| } | |
| bool SendKeysCommandHandler::SendFileNameKeys(FileNameData* file_data) { | |
| CComPtr<IUIAutomation> ui_automation; | |
| HRESULT hr = ::CoCreateInstance(CLSID_CUIAutomation, | |
| NULL, | |
| CLSCTX_INPROC_SERVER, | |
| IID_IUIAutomation, | |
| reinterpret_cast<void**>(&ui_automation)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to create global UI Automation object"; | |
| error_text = L"The driver was unable to initialize the Windows UI Automation system. This is a Windows installation problem, not a driver problem."; | |
| return false; | |
| } | |
| std::vector<HWND> window_handles = FindWindowCandidates(file_data); | |
| // Find all candidates for the file selection dialog. Retry until timeout. | |
| int max_retries = file_data->dialogTimeout / 100; | |
| CComPtr<IUIAutomationElementArray> dialog_candidates; | |
| bool dialog_candidates_found = GetFileSelectionDialogCandidates(window_handles, | |
| ui_automation, | |
| &dialog_candidates); | |
| while (!dialog_candidates_found && --max_retries) { | |
| dialog_candidates.Release(); | |
| ::Sleep(100); | |
| window_handles = FindWindowCandidates(file_data); | |
| dialog_candidates_found = GetFileSelectionDialogCandidates(window_handles, | |
| ui_automation, | |
| &dialog_candidates); | |
| } | |
| if (!dialog_candidates_found) { | |
| LOG(WARN) << "Did not find any dialogs after dialog timeout"; | |
| error_text = L"The driver did not find the file selection dialog before the timeout."; | |
| return false; | |
| } | |
| // We must have a valid array of dialog candidates at this point, | |
| // so we should be able to safely ignore checking for error values. | |
| int window_array_length = 0; | |
| hr = dialog_candidates->get_Length(&window_array_length); | |
| for (int i = 0; i < window_array_length; ++i) { | |
| CComPtr<IUIAutomationElement> file_selection_dialog; | |
| hr = dialog_candidates->GetElement(i, &file_selection_dialog); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to get element " << i << " from list of child dialogs of IE main window, trying next dialog"; | |
| continue; | |
| } | |
| if (!FillFileName(file_data->text, ui_automation, file_selection_dialog)) { | |
| continue; | |
| } | |
| if (!AcceptFileSelection(ui_automation, file_selection_dialog)) { | |
| continue; | |
| } | |
| if (WaitForFileSelectionDialogClose(file_data->dialogTimeout, | |
| file_selection_dialog)) { | |
| // Full success case. Break out of loop and return true. | |
| break; | |
| } | |
| // At this point, successfully found a file selection dialog, set its file name | |
| // and attempted to accept the selection. However, the file selection dialog didn't | |
| // close in a timely fashion, which indicates an error condition thrown up by the | |
| // browser. Check for an error dialog, and if one is found, dismiss it and the file | |
| // selection dialog so as not to hang the driver. | |
| CComPtr<IUIAutomationElement> error_dialog; | |
| if (!FindFileSelectionErrorDialog(ui_automation, | |
| file_selection_dialog, | |
| &error_dialog)) { | |
| error_text = L"The driver found the file selection dialog, set the file information, and clicked the open button, but the dialog did not close in a timely manner."; | |
| return false; | |
| } | |
| if (!DismissFileSelectionErrorDialog(ui_automation, error_dialog)) { | |
| return false; | |
| } | |
| if (!DismissFileSelectionDialog(ui_automation, file_selection_dialog)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| BOOL CALLBACK SendKeysCommandHandler::FindWindowWithClassNameAndProcess(HWND hwnd, LPARAM arg) { | |
| DialogParentWindowInfo* process_win_info = reinterpret_cast<DialogParentWindowInfo*>(arg); | |
| size_t number_of_characters = wcsnlen(process_win_info->class_name, 255); | |
| std::vector<wchar_t> class_name(number_of_characters + 1); | |
| if (::GetClassName(hwnd, &class_name[0], static_cast<int>(class_name.size())) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (wcscmp(process_win_info->class_name, &class_name[0]) != 0) { | |
| return TRUE; | |
| } else { | |
| DWORD process_id = NULL; | |
| ::GetWindowThreadProcessId(hwnd, &process_id); | |
| if (process_win_info->process_id == process_id) { | |
| // Once we've found the first dialog (#32770) window | |
| // for the process we want, we can stop. | |
| process_win_info->window_handle = hwnd; | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| unsigned int WINAPI SendKeysCommandHandler::SetFileValue(void *file_data) { | |
| FileNameData* data = reinterpret_cast<FileNameData*>(file_data); | |
| ::Sleep(100); | |
| bool file_name_successfully_sent = false; | |
| unsigned int return_value = 0; | |
| // On a separate thread, so must reinitialize COM. | |
| HRESULT hr = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); | |
| if (FAILED(hr)) { | |
| return_value = 1; | |
| LOGHR(WARN, hr) << "COM library initialization encountered an error"; | |
| error_text = L"The driver could not initialize COM on the thread used to handle the file selection dialog."; | |
| } else { | |
| file_name_successfully_sent = SendFileNameKeys(data); | |
| ::CoUninitialize(); | |
| if (!file_name_successfully_sent) { | |
| return_value = 1; | |
| } | |
| } | |
| // TODO: Remove this and the supporting functions once feedback | |
| // on the use of UI Automation is completed. | |
| if (!file_name_successfully_sent && data->useLegacyDialogHandling) { | |
| LegacySelectFile(data); | |
| } | |
| return return_value; | |
| } | |
| bool SendKeysCommandHandler::LegacySelectFile(FileNameData* data) { | |
| HWND ie_main_window_handle = data->main; | |
| HWND dialog_window_handle = ::GetLastActivePopup(ie_main_window_handle); | |
| int max_retries = data->dialogTimeout / 100; | |
| if (!dialog_window_handle || | |
| (dialog_window_handle == ie_main_window_handle)) { | |
| LOG(DEBUG) << "No dialog directly owned by the top-level window found. " | |
| << "Beginning search for dialog. Will search for " | |
| << max_retries << " attempts at 100ms intervals."; | |
| // No dialog directly owned by the top-level window. | |
| // Look for a dialog belonging to the same process as | |
| // the IE server window. This isn't perfect, but it's | |
| // all we have for now. | |
| while ((dialog_window_handle == ie_main_window_handle) && --max_retries) { | |
| ::Sleep(100); | |
| ProcessWindowInfo process_win_info; | |
| process_win_info.dwProcessId = data->ieProcId; | |
| ::EnumWindows(&BrowserFactory::FindDialogWindowForProcess, | |
| reinterpret_cast<LPARAM>(&process_win_info)); | |
| if (process_win_info.hwndBrowser != NULL) { | |
| dialog_window_handle = process_win_info.hwndBrowser; | |
| } | |
| } | |
| } | |
| if (!dialog_window_handle || | |
| (dialog_window_handle == ie_main_window_handle)) { | |
| LOG(DEBUG) << "Did not find dialog owned by IE process. " | |
| << "Searching again using GetLastActivePopup API."; | |
| max_retries = data->dialogTimeout / 100; | |
| while ((dialog_window_handle == ie_main_window_handle) && --max_retries) { | |
| ::Sleep(100); | |
| dialog_window_handle = ::GetLastActivePopup(ie_main_window_handle); | |
| } | |
| } | |
| if (!dialog_window_handle || | |
| (dialog_window_handle == ie_main_window_handle)) { | |
| LOG(WARN) << "No dialog found"; | |
| return false; | |
| } | |
| LOG(DEBUG) << "Found file upload dialog with handle " | |
| << StringUtilities::Format("0x%08X", dialog_window_handle) | |
| << ". Window has caption '" | |
| << WindowUtilities::GetWindowCaption(dialog_window_handle) | |
| << "' Starting to look for file name edit control."; | |
| return LegacySendKeysToFileUploadAlert(dialog_window_handle, data->text); | |
| } | |
| bool SendKeysCommandHandler::LegacySendKeysToFileUploadAlert( | |
| HWND dialog_window_handle, | |
| const wchar_t* value) { | |
| HWND edit_field_window_handle = NULL; | |
| int max_wait = MAXIMUM_CONTROL_FIND_RETRIES; | |
| while (!edit_field_window_handle && --max_wait) { | |
| WindowUtilities::Wait(200); | |
| edit_field_window_handle = dialog_window_handle; | |
| for (int i = 1; fileDialogNames[i]; ++i) { | |
| std::wstring child_window_class = fileDialogNames[i]; | |
| edit_field_window_handle = WindowUtilities::GetChildWindow( | |
| edit_field_window_handle, | |
| child_window_class); | |
| if (!edit_field_window_handle) { | |
| LOG(WARN) << "Didn't find window with class name '" | |
| << LOGWSTRING(child_window_class) | |
| << "' during attempt " | |
| << MAXIMUM_CONTROL_FIND_RETRIES - max_wait | |
| << " of " << MAXIMUM_CONTROL_FIND_RETRIES << "."; | |
| } | |
| } | |
| } | |
| if (edit_field_window_handle) { | |
| // Attempt to set the value, looping until we succeed. | |
| LOG(DEBUG) << "Found edit control on file selection dialog"; | |
| const wchar_t* filename = value; | |
| size_t expected = wcslen(filename); | |
| size_t curr = 0; | |
| max_wait = MAXIMUM_CONTROL_FIND_RETRIES; | |
| while ((expected != curr) && --max_wait) { | |
| ::SendMessage(edit_field_window_handle, | |
| WM_SETTEXT, | |
| 0, | |
| reinterpret_cast<LPARAM>(filename)); | |
| WindowUtilities::Wait(1000); | |
| curr = ::SendMessage(edit_field_window_handle, WM_GETTEXTLENGTH, 0, 0); | |
| } | |
| if (expected != curr) { | |
| LOG(WARN) << "Did not send the expected number of characters to the " | |
| << "file name control. Expected: " << expected << ", " | |
| << "Actual: " << curr; | |
| } | |
| max_wait = MAXIMUM_DIALOG_FIND_RETRIES; | |
| bool triedToDismiss = false; | |
| for (int i = 0; i < max_wait; i++) { | |
| HWND open_button_window_handle = ::GetDlgItem(dialog_window_handle, | |
| IDOK); | |
| if (open_button_window_handle) { | |
| LRESULT total = 0; | |
| total += ::SendMessage(open_button_window_handle, | |
| WM_LBUTTONDOWN, | |
| 0, | |
| 0); | |
| total += ::SendMessage(open_button_window_handle, | |
| WM_LBUTTONUP, | |
| 0, | |
| 0); | |
| // SendMessage should return zero for those messages if properly | |
| // processed. | |
| if (total == 0) { | |
| triedToDismiss = true; | |
| // Sometimes IE10 doesn't dismiss this dialog after the messages | |
| // are received, even though the messages were processed | |
| // successfully. If not, try again, just in case. | |
| if (!::IsWindow(dialog_window_handle)) { | |
| LOG(DEBUG) << "Dialog successfully dismissed"; | |
| return true; | |
| } | |
| } | |
| WindowUtilities::Wait(200); | |
| } | |
| else if (triedToDismiss) { | |
| // Probably just a slow close | |
| LOG(DEBUG) << "Did not find OK button, but did previously. Assume dialog dismiss worked."; | |
| return true; | |
| } | |
| } | |
| LOG(ERROR) << "Unable to set value of file input dialog"; | |
| return false; | |
| } | |
| LOG(WARN) << "No edit found"; | |
| return false; | |
| } | |
| bool SendKeysCommandHandler::VerifyPageHasFocus(BrowserHandle browser_wrapper) { | |
| HWND browser_pane_window_handle = browser_wrapper->GetContentWindowHandle(); | |
| DWORD proc; | |
| DWORD thread_id = ::GetWindowThreadProcessId(browser_pane_window_handle, &proc); | |
| GUITHREADINFO info; | |
| info.cbSize = sizeof(GUITHREADINFO); | |
| ::GetGUIThreadInfo(thread_id, &info); | |
| if (info.hwndFocus != browser_pane_window_handle) { | |
| LOG(INFO) << "Focus is on a UI element other than the HTML viewer pane."; | |
| // The focus is on a UI element other than the HTML viewer pane (like | |
| // the address bar, for instance). This has implications for certain | |
| // keystrokes, like backspace. We need to set the focus to the HTML | |
| // viewer pane. | |
| // N.B. The SetFocus() API should *NOT* cause the IE browser window to | |
| // magically appear in the foreground. If that is not true, we will need | |
| // to find some other solution. | |
| // Send an explicit WM_KILLFOCUS message to free up SetFocus() to place the | |
| // focus on the correct window. While SetFocus() is supposed to already do | |
| // this, it seems to not work entirely correctly. | |
| ::SendMessage(info.hwndFocus, WM_KILLFOCUS, NULL, NULL); | |
| DWORD current_thread_id = ::GetCurrentThreadId(); | |
| ::AttachThreadInput(current_thread_id, thread_id, TRUE); | |
| HWND previous_focus = ::SetFocus(browser_pane_window_handle); | |
| if (previous_focus == NULL) { | |
| LOGERR(WARN) << "SetFocus API call failed"; | |
| } | |
| ::AttachThreadInput(current_thread_id, thread_id, FALSE); | |
| ::GetGUIThreadInfo(thread_id, &info); | |
| } | |
| return info.hwndFocus == browser_pane_window_handle; | |
| } | |
| bool SendKeysCommandHandler::WaitUntilElementFocused(ElementHandle element_wrapper) { | |
| // Check we have focused the element. | |
| CComPtr<IHTMLElement> element = element_wrapper->element(); | |
| bool has_focus = false; | |
| CComPtr<IDispatch> dispatch; | |
| element->get_document(&dispatch); | |
| CComPtr<IHTMLDocument2> document; | |
| dispatch->QueryInterface<IHTMLDocument2>(&document); | |
| // If the element we want is already the focused element, we're done. | |
| CComPtr<IHTMLElement> active_element; | |
| if (document->get_activeElement(&active_element) == S_OK) { | |
| if (active_element.IsEqualObject(element)) { | |
| if (this->IsContentEditable(element)) { | |
| this->SetElementFocus(element); | |
| } | |
| return true; | |
| } | |
| } | |
| this->SetElementFocus(element); | |
| // Hard-coded 1 second timeout here. Possible TODO is make this adjustable. | |
| clock_t max_wait = clock() + CLOCKS_PER_SEC; | |
| for (int i = clock(); i < max_wait; i = clock()) { | |
| WindowUtilities::Wait(1); | |
| CComPtr<IHTMLElement> active_wait_element; | |
| if (document->get_activeElement(&active_wait_element) == S_OK && active_wait_element != NULL) { | |
| CComPtr<IHTMLElement2> element2; | |
| element->QueryInterface<IHTMLElement2>(&element2); | |
| CComPtr<IHTMLElement2> active_wait_element2; | |
| active_wait_element->QueryInterface<IHTMLElement2>(&active_wait_element2); | |
| if (element2.IsEqualObject(active_wait_element2)) { | |
| this->SetInsertionPoint(element); | |
| has_focus = true; | |
| break; | |
| } | |
| } | |
| } | |
| return has_focus; | |
| } | |
| bool SendKeysCommandHandler::SetInsertionPoint(IHTMLElement* element) { | |
| CComPtr<IHTMLTxtRange> range; | |
| CComPtr<IHTMLInputTextElement> input_element; | |
| HRESULT hr = element->QueryInterface<IHTMLInputTextElement>(&input_element); | |
| if (SUCCEEDED(hr) && input_element) { | |
| input_element->createTextRange(&range); | |
| } else { | |
| CComPtr<IHTMLTextAreaElement> text_area_element; | |
| hr = element->QueryInterface<IHTMLTextAreaElement>(&text_area_element); | |
| if (SUCCEEDED(hr) && text_area_element) { | |
| text_area_element->createTextRange(&range); | |
| } else { | |
| bool is_content_editable = this->IsContentEditable(element); | |
| if (is_content_editable) { | |
| CComPtr<IDispatch> dispatch; | |
| hr = element->get_document(&dispatch); | |
| if (dispatch) { | |
| CComPtr<IHTMLDocument2> doc; | |
| hr = dispatch->QueryInterface<IHTMLDocument2>(&doc); | |
| if (doc) { | |
| CComPtr<IHTMLElement> body; | |
| hr = doc->get_body(&body); | |
| if (body) { | |
| CComPtr<IHTMLBodyElement> body_element; | |
| hr = body->QueryInterface<IHTMLBodyElement>(&body_element); | |
| if (body_element) { | |
| hr = body_element->createTextRange(&range); | |
| range->moveToElementText(element); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (range) { | |
| range->collapse(VARIANT_FALSE); | |
| range->select(); | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool SendKeysCommandHandler::IsContentEditable(IHTMLElement* element) { | |
| CComPtr<IHTMLElement3> element3; | |
| element->QueryInterface<IHTMLElement3>(&element3); | |
| VARIANT_BOOL is_content_editable_variant = VARIANT_FALSE; | |
| if (element3) { | |
| element3->get_isContentEditable(&is_content_editable_variant); | |
| } | |
| return is_content_editable_variant == VARIANT_TRUE; | |
| } | |
| void SendKeysCommandHandler::SetElementFocus(IHTMLElement* element) { | |
| CComPtr<IHTMLElement2> element2; | |
| element->QueryInterface<IHTMLElement2>(&element2); | |
| element2->focus(); | |
| } | |
| } // namespace webdriver |