| // 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 "NewSessionCommandHandler.h" | |
| #include "errorcodes.h" | |
| #include "logging.h" | |
| #include "../Alert.h" | |
| #include "../Browser.h" | |
| #include "../BrowserFactory.h" | |
| #include "../IECommandExecutor.h" | |
| #include "../InputManager.h" | |
| #include "../ProxyManager.h" | |
| #include "../WebDriverConstants.h" | |
| namespace webdriver { | |
| NewSessionCommandHandler::NewSessionCommandHandler(void) { | |
| } | |
| NewSessionCommandHandler::~NewSessionCommandHandler(void) { | |
| } | |
| void NewSessionCommandHandler::ExecuteInternal( | |
| const IECommandExecutor& executor, | |
| const ParametersMap& command_parameters, | |
| Response* response) { | |
| Json::Value returned_capabilities; | |
| std::string error_message = ""; | |
| // Find W3C capabilities first. | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| ParametersMap::const_iterator it = command_parameters.find("capabilities"); | |
| if (it != command_parameters.end()) { | |
| LOG(DEBUG) << "Found W3C capabilities structure"; | |
| Json::Value validated_capabilities = this->ValidateArguments(it->second, | |
| &error_message); | |
| if (validated_capabilities.size() == 0) { | |
| // validated_capabilities returns an array with validated capabilities | |
| // in it. If there are no entries in the array, then something failed | |
| // validation. The error_message string will tell us what. | |
| mutable_executor.set_is_valid(false); | |
| response->SetErrorResponse(ERROR_INVALID_ARGUMENT, error_message); | |
| return; | |
| } | |
| error_message = ""; | |
| returned_capabilities = this->ProcessCapabilities(executor, | |
| validated_capabilities, | |
| &error_message); | |
| } else { | |
| error_message = "No property named 'capabilities' found in new session request body."; | |
| mutable_executor.set_is_valid(false); | |
| response->SetErrorResponse(ERROR_INVALID_ARGUMENT, error_message); | |
| return; | |
| } | |
| if (returned_capabilities.isNull()) { | |
| // The browser was not created successfully, therefore the | |
| // session must be marked as invalid so the server can | |
| // properly shut it down. | |
| mutable_executor.set_is_valid(false); | |
| response->SetErrorResponse(ERROR_SESSION_NOT_CREATED, error_message); | |
| return; | |
| } | |
| error_message = ""; | |
| int result_code = mutable_executor.CreateNewBrowser(&error_message); | |
| if (result_code != WD_SUCCESS) { | |
| // The browser was not created successfully, therefore the | |
| // session must be marked as invalid so the server can | |
| // properly shut it down. | |
| mutable_executor.set_is_valid(false); | |
| response->SetErrorResponse(ERROR_SESSION_NOT_CREATED, | |
| "Unexpected error launching Internet Explorer. " + error_message); | |
| return; | |
| } | |
| Json::Value new_session_response_object; | |
| new_session_response_object["sessionId"] = executor.session_id(); | |
| new_session_response_object["capabilities"] = returned_capabilities; | |
| response->SetSuccessResponse(new_session_response_object); | |
| } | |
| Json::Value NewSessionCommandHandler::GetCapability( | |
| const Json::Value& capabilities, | |
| const std::string& capability_name, | |
| const Json::ValueType& expected_capability_type, | |
| const Json::Value& default_value) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::GetCapability " | |
| << "for capability " << capability_name; | |
| Json::Value capability_value = capabilities.get(capability_name, default_value); | |
| if (!this->IsEquivalentType(capability_value.type(), expected_capability_type)) { | |
| LOG(WARN) << "Invalid capability setting: " << capability_name | |
| << " is type " << this->GetJsonTypeDescription(capability_value.type()) | |
| << " instead of " << this->GetJsonTypeDescription(expected_capability_type) | |
| << ". Default value will be used: " << default_value.toStyledString(); | |
| return default_value; | |
| } | |
| return capability_value; | |
| } | |
| bool NewSessionCommandHandler::IsEquivalentType( | |
| const Json::ValueType& actual_type, | |
| const Json::ValueType& expected_type) { | |
| if (expected_type == actual_type) { | |
| return true; | |
| } | |
| if ((expected_type == Json::intValue || expected_type == Json::uintValue || expected_type == Json::realValue) && | |
| (actual_type == Json::intValue || actual_type == Json::uintValue || actual_type == Json::realValue)) { | |
| // All numeric types are equivalent for our purposes. | |
| return true; | |
| } | |
| return false; | |
| } | |
| std::string NewSessionCommandHandler::GetJsonTypeDescription( | |
| const Json::ValueType& type) { | |
| switch (type) { | |
| case Json::booleanValue: | |
| return "boolean"; | |
| case Json::intValue: | |
| case Json::uintValue: | |
| case Json::realValue: | |
| return "number"; | |
| case Json::objectValue: | |
| return "object"; | |
| case Json::arrayValue: | |
| return "array"; | |
| case Json::stringValue: | |
| return "string"; | |
| } | |
| return "null"; | |
| } | |
| std::string NewSessionCommandHandler::GetUnexpectedAlertBehaviorValue( | |
| const std::string& desired_value) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::GetUnexpectedAlertBehaviorValue"; | |
| std::string value = DISMISS_AND_NOTIFY_UNEXPECTED_ALERTS; | |
| if (desired_value == DISMISS_UNEXPECTED_ALERTS || | |
| desired_value == ACCEPT_UNEXPECTED_ALERTS || | |
| desired_value == ACCEPT_AND_NOTIFY_UNEXPECTED_ALERTS || | |
| desired_value == DISMISS_AND_NOTIFY_UNEXPECTED_ALERTS || | |
| desired_value == IGNORE_UNEXPECTED_ALERTS) { | |
| value = desired_value; | |
| } else { | |
| LOG(WARN) << "Desired value of " << desired_value << " for " | |
| << UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY << " is not" | |
| << " a valid value. Using default of " << value; | |
| } | |
| return value; | |
| } | |
| std::string NewSessionCommandHandler::GetPageLoadStrategyValue( | |
| const std::string& desired_value) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::GetPageLoadStrategyValue"; | |
| std::string value = NORMAL_PAGE_LOAD_STRATEGY; | |
| if (desired_value == NORMAL_PAGE_LOAD_STRATEGY || | |
| desired_value == EAGER_PAGE_LOAD_STRATEGY || | |
| desired_value == NONE_PAGE_LOAD_STRATEGY) { | |
| value = desired_value; | |
| } else { | |
| LOG(WARN) << "Desired value of " << desired_value << " for " | |
| << PAGE_LOAD_STRATEGY_CAPABILITY << " is not" | |
| << " a valid value. Using default of " << value; | |
| } | |
| return value; | |
| } | |
| Json::Value NewSessionCommandHandler::ValidateArguments(const Json::Value& capabilities, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::ValidateArguments"; | |
| Json::Value validated_capabilities(Json::arrayValue); | |
| if (!capabilities.isObject()) { | |
| *error_message = "'capabilities' in new session request body is not a JSON object."; | |
| return validated_capabilities; | |
| } | |
| Json::Value always_match(Json::objectValue); | |
| if (capabilities.isMember("alwaysMatch")) { | |
| LOG(DEBUG) << "Found alwaysMatch in capabilities"; | |
| always_match = capabilities["alwaysMatch"]; | |
| if (!always_match.isObject()) { | |
| *error_message = "alwaysMatch must be a JSON object"; | |
| return validated_capabilities; | |
| } | |
| } | |
| LOG(DEBUG) << "Validating alwaysMatch capability set"; | |
| if (this->ValidateCapabilities(always_match, "alwaysMatch", error_message)) { | |
| Json::Value empty_capabilities(Json::objectValue); | |
| Json::Value first_match_candidates(Json::arrayValue); | |
| first_match_candidates.append(empty_capabilities); | |
| if (capabilities.isMember("firstMatch")) { | |
| first_match_candidates = capabilities["firstMatch"]; | |
| } | |
| if (!first_match_candidates.isArray()) { | |
| *error_message = "firstMatch must be a JSON list"; | |
| return validated_capabilities; | |
| } else { | |
| // If the user passed a "firstMatch" array, but it was empty, | |
| // seed the firstMatch array with an empty object for merging | |
| // purposes. | |
| if (first_match_candidates.size() == 0) { | |
| first_match_candidates.append(empty_capabilities); | |
| } | |
| bool first_match_validation_failure = false; | |
| Json::Value validated_first_match_candidates(Json::arrayValue); | |
| for (size_t i = 0; i < first_match_candidates.size(); ++i) { | |
| LOG(DEBUG) << "Validating firstMatch capability set with index " << i; | |
| std::string first_match_validation_error = ""; | |
| Json::Value first_match_candidate = first_match_candidates[static_cast<int>(i)]; | |
| if (this->ValidateCapabilities(first_match_candidate, | |
| "firstMatch element " + std::to_string(i), | |
| &first_match_validation_error)) { | |
| validated_first_match_candidates.append(first_match_candidate); | |
| } else { | |
| first_match_validation_failure = true; | |
| if (error_message->size() == 0) { | |
| error_message->append("All firstMatch elements failed validation\n"); | |
| } else { | |
| error_message->append("\n"); | |
| } | |
| error_message->append(first_match_validation_error); | |
| } | |
| } | |
| if (first_match_validation_failure) { | |
| return validated_capabilities; | |
| } | |
| // Because we seed the list of "firstMatch" values with an empty value | |
| // if none were passed in, we should always have at least one element | |
| // in the array of firstMatch candidates. If we don't then every one | |
| // has failed validation, and we need to return back out. | |
| if (validated_first_match_candidates.size() > 0) { | |
| // Reset the error message in the event any of the firstMatch | |
| // candidates failed validation. | |
| *error_message = ""; | |
| for (size_t i = 0; i < validated_first_match_candidates.size(); ++i) { | |
| Json::Value merged_capabilities(Json::objectValue); | |
| Json::Value first_match = validated_first_match_candidates[static_cast<int>(i)]; | |
| if (!this->MergeCapabilities(always_match, | |
| first_match, | |
| &merged_capabilities, | |
| error_message)) { | |
| // If any of the capabilities can't be merged, this is a failure | |
| // condition according to the spec, so we fail here, returning an | |
| // empty array. | |
| return Json::Value(Json::arrayValue); | |
| } | |
| validated_capabilities.append(merged_capabilities); | |
| } | |
| } | |
| } | |
| } | |
| return validated_capabilities; | |
| } | |
| Json::Value NewSessionCommandHandler::ProcessCapabilities(const IECommandExecutor& executor, | |
| const Json::Value& capabilities, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::ProcessCapabilities"; | |
| for (size_t i = 0; i < capabilities.size(); ++i) { | |
| std::string match_error = ""; | |
| Json::Value merged_capabilities = capabilities[static_cast<int>(i)]; | |
| if (this->MatchCapabilities(executor, merged_capabilities, &match_error)) { | |
| LOG(DEBUG) << "Processing matched capability set with index " << i; | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| Json::Value unexpected_alert_behavior = this->GetCapability(merged_capabilities, | |
| UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY, | |
| Json::stringValue, | |
| Json::Value(Json::stringValue)); | |
| mutable_executor.set_unexpected_alert_behavior(unexpected_alert_behavior.asString()); | |
| Json::Value page_load_strategy = this->GetCapability(merged_capabilities, | |
| PAGE_LOAD_STRATEGY_CAPABILITY, | |
| Json::stringValue, | |
| NORMAL_PAGE_LOAD_STRATEGY); | |
| mutable_executor.set_page_load_strategy(this->GetPageLoadStrategyValue(page_load_strategy.asString())); | |
| Json::Value use_strict_file_interactability = this->GetCapability(merged_capabilities, | |
| STRICT_FILE_INTERACTABILITY_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| mutable_executor.set_use_strict_file_interactability(use_strict_file_interactability.asBool()); | |
| Json::Value timeouts = this->GetCapability(merged_capabilities, | |
| TIMEOUTS_CAPABILITY, | |
| Json::objectValue, | |
| Json::Value()); | |
| this->SetTimeoutSettings(executor, timeouts); | |
| Json::Value ie_options(Json::objectValue); | |
| if (merged_capabilities.isMember(IE_DRIVER_EXTENSIONS_CAPABILITY)) { | |
| ie_options = merged_capabilities[IE_DRIVER_EXTENSIONS_CAPABILITY]; | |
| } | |
| this->SetBrowserFactorySettings(executor, ie_options); | |
| this->SetInputSettings(executor, ie_options); | |
| if (merged_capabilities.isMember(PROXY_CAPABILITY)) { | |
| Json::Value use_per_process_proxy_capability = this->GetCapability(ie_options, | |
| USE_PER_PROCESS_PROXY_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| bool use_per_process_proxy = use_per_process_proxy_capability.asBool(); | |
| this->SetProxySettings(executor, | |
| merged_capabilities[PROXY_CAPABILITY], | |
| use_per_process_proxy); | |
| } | |
| // Use CreateReturnedCapabilities to fill in unspecified capabilities values. | |
| return this->CreateReturnedCapabilities(executor); | |
| } else { | |
| if (error_message->size() == 0) { | |
| error_message->append("No matching capability sets found.\n"); | |
| } else { | |
| error_message->append("\n"); | |
| } | |
| error_message->append("Unable to match capability set "); | |
| error_message->append(std::to_string(i)); | |
| error_message->append(": "); | |
| error_message->append(match_error); | |
| } | |
| } | |
| return Json::Value(Json::nullValue); | |
| } | |
| void NewSessionCommandHandler::SetTimeoutSettings(const IECommandExecutor& executor, | |
| const Json::Value& capabilities) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::SetTimeoutSettings"; | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| if (capabilities.isMember(IMPLICIT_WAIT_TIMEOUT_NAME)) { | |
| mutable_executor.set_implicit_wait_timeout(capabilities[IMPLICIT_WAIT_TIMEOUT_NAME].asUInt64()); | |
| } | |
| if (capabilities.isMember(PAGE_LOAD_TIMEOUT_NAME)) { | |
| mutable_executor.set_page_load_timeout(capabilities[PAGE_LOAD_TIMEOUT_NAME].asUInt64()); | |
| } | |
| if (capabilities.isMember(SCRIPT_TIMEOUT_NAME)) { | |
| if (capabilities[SCRIPT_TIMEOUT_NAME].isNull()) { | |
| mutable_executor.set_async_script_timeout(-1); | |
| } else { | |
| mutable_executor.set_async_script_timeout(capabilities[SCRIPT_TIMEOUT_NAME].asInt64()); | |
| } | |
| } | |
| } | |
| void NewSessionCommandHandler::SetBrowserFactorySettings(const IECommandExecutor& executor, | |
| const Json::Value& capabilities) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::SetBrowserFactorySettings"; | |
| std::string default_initial_url = "http://localhost:" + std::to_string(static_cast<long long>(executor.port())) + "/"; | |
| if (!capabilities.isNull()) { | |
| BrowserFactorySettings factory_settings; | |
| Json::Value ignore_protected_mode_settings = this->GetCapability(capabilities, | |
| IGNORE_PROTECTED_MODE_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.ignore_protected_mode_settings = ignore_protected_mode_settings.asBool(); | |
| Json::Value ignore_zoom_setting = this->GetCapability(capabilities, | |
| IGNORE_ZOOM_SETTING_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.ignore_zoom_setting = ignore_zoom_setting.asBool(); | |
| Json::Value browser_attach_timeout = this->GetCapability(capabilities, | |
| BROWSER_ATTACH_TIMEOUT_CAPABILITY, | |
| Json::intValue, | |
| Json::Value(Json::intValue)); | |
| factory_settings.browser_attach_timeout = browser_attach_timeout.asInt(); | |
| Json::Value initial_url = this->GetCapability(capabilities, | |
| INITIAL_BROWSER_URL_CAPABILITY, | |
| Json::stringValue, default_initial_url); | |
| factory_settings.initial_browser_url = initial_url.asString(); | |
| Json::Value force_create_process_api = this->GetCapability(capabilities, | |
| FORCE_CREATE_PROCESS_API_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.force_create_process_api = force_create_process_api.asBool(); | |
| Json::Value force_shell_windows_api = this->GetCapability(capabilities, | |
| FORCE_SHELL_WINDOWS_API_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.force_shell_windows_api = force_shell_windows_api.asBool(); | |
| Json::Value browser_command_line_switches = this->GetCapability(capabilities, | |
| BROWSER_COMMAND_LINE_SWITCHES_CAPABILITY, | |
| Json::stringValue, | |
| Json::Value(Json::stringValue)); | |
| factory_settings.browser_command_line_switches = browser_command_line_switches.asString(); | |
| Json::Value ensure_clean_session = this->GetCapability(capabilities, | |
| ENSURE_CLEAN_SESSION_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.clear_cache_before_launch = ensure_clean_session.asBool(); | |
| // By default, we should not be attaching to edge_ie | |
| factory_settings.attach_to_edge_ie = false; | |
| Json::Value attach_to_edgechrome = this->GetCapability(capabilities, | |
| ATTACH_TO_EDGE_CHROME, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.attach_to_edge_ie = attach_to_edgechrome.asBool(); | |
| // Ignore window handle process id match when launching Edge on IE Mode | |
| // Useful when the process is launched with admin/privilege rights. This | |
| // assumes only one Edge browser is running on the host. | |
| factory_settings.ignore_process_match = false; | |
| Json::Value ignore_process_match_ie_mode = this->GetCapability(capabilities, | |
| IGNORE_PROCESS_MATCH, | |
| Json::booleanValue, | |
| false); | |
| factory_settings.ignore_process_match = ignore_process_match_ie_mode.asBool(); | |
| Json::Value edge_executable_path = this->GetCapability(capabilities, | |
| EDGE_EXECUTABLE_PATH, | |
| Json::stringValue, | |
| Json::Value(Json::stringValue)); | |
| factory_settings.edge_executable_path = edge_executable_path.asString(); | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| mutable_executor.browser_factory()->Initialize(factory_settings); | |
| mutable_executor.set_is_edge_mode(factory_settings.attach_to_edge_ie); | |
| mutable_executor.set_edge_executable_path(factory_settings.edge_executable_path); | |
| } | |
| } | |
| void NewSessionCommandHandler::SetProxySettings(const IECommandExecutor& executor, | |
| const Json::Value& proxy_capability, | |
| const bool use_per_process_proxy) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::SetProxySettings"; | |
| ProxySettings proxy_settings = { false, "", "", "", "", "", "", "", "", "" }; | |
| if (!proxy_capability.isNull()) { | |
| // TODO(JimEvans): Validate the members of the proxy JSON object. | |
| std::string proxy_type = proxy_capability.get("proxyType", "").asString(); | |
| proxy_settings.proxy_type = proxy_type; | |
| std::string http_proxy = proxy_capability.get("httpProxy", "").asString(); | |
| proxy_settings.http_proxy = http_proxy; | |
| std::string ftp_proxy = proxy_capability.get("ftpProxy", "").asString(); | |
| proxy_settings.ftp_proxy = ftp_proxy; | |
| std::string ssl_proxy = proxy_capability.get("sslProxy", "").asString(); | |
| proxy_settings.ssl_proxy = ssl_proxy; | |
| std::string socks_proxy = proxy_capability.get("socksProxy", "").asString(); | |
| proxy_settings.socks_proxy = socks_proxy; | |
| if (socks_proxy.length() > 0) { | |
| // SOCKS proxy user name and password capabilities are ignored if the | |
| // SOCKS proxy is unset. | |
| std::string socks_user_name = proxy_capability.get("socksUsername", "").asString(); | |
| proxy_settings.socks_user_name = socks_user_name; | |
| std::string socks_password = proxy_capability.get("socksPassword", "").asString(); | |
| proxy_settings.socks_password = socks_password; | |
| } | |
| std::string autoconfig_url = proxy_capability.get("proxyAutoconfigUrl", "").asString(); | |
| proxy_settings.proxy_autoconfig_url = autoconfig_url; | |
| Json::Value proxy_bypass_list = proxy_capability.get("noProxy", Json::Value::null); | |
| if (!proxy_bypass_list.isNull() && proxy_bypass_list.isArray()) { | |
| std::string no_proxy = ""; | |
| for (size_t i = 0; i < proxy_bypass_list.size(); ++i) { | |
| if (no_proxy.size() > 0) { | |
| no_proxy.append(";"); | |
| } | |
| no_proxy.append(proxy_bypass_list[static_cast<int>(i)].asString()); | |
| } | |
| proxy_settings.proxy_bypass = no_proxy; | |
| } | |
| proxy_settings.use_per_process_proxy = use_per_process_proxy; | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| mutable_executor.proxy_manager()->Initialize(proxy_settings); | |
| } | |
| } | |
| void NewSessionCommandHandler::SetInputSettings(const IECommandExecutor& executor, | |
| const Json::Value& capabilities) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::SetInputSettings"; | |
| IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor); | |
| InputManagerSettings input_manager_settings; | |
| input_manager_settings.element_repository = mutable_executor.element_manager(); | |
| Json::Value enable_native_events = this->GetCapability(capabilities, | |
| NATIVE_EVENTS_CAPABILITY, | |
| Json::booleanValue, | |
| true); | |
| input_manager_settings.use_native_events = enable_native_events.asBool(); | |
| Json::Value scroll_behavior = this->GetCapability(capabilities, | |
| ELEMENT_SCROLL_BEHAVIOR_CAPABILITY, | |
| Json::intValue, | |
| Json::Value(Json::intValue)); | |
| input_manager_settings.scroll_behavior = static_cast<ElementScrollBehavior>(scroll_behavior.asInt()); | |
| Json::Value require_window_focus = this->GetCapability(capabilities, | |
| REQUIRE_WINDOW_FOCUS_CAPABILITY, | |
| Json::booleanValue, | |
| false); | |
| input_manager_settings.require_window_focus = require_window_focus.asBool(); | |
| Json::Value file_upload_dialog_timeout = this->GetCapability(capabilities, | |
| FILE_UPLOAD_DIALOG_TIMEOUT_CAPABILITY, | |
| Json::intValue, | |
| Json::Value(Json::intValue)); | |
| if (file_upload_dialog_timeout.asInt() > 0) { | |
| mutable_executor.set_file_upload_dialog_timeout(file_upload_dialog_timeout.asInt()); | |
| } | |
| Json::Value enable_persistent_hover = this->GetCapability(capabilities, | |
| ENABLE_PERSISTENT_HOVER_CAPABILITY, | |
| Json::booleanValue, | |
| true); | |
| if (require_window_focus.asBool() || !enable_native_events.asBool()) { | |
| // Setting "require_window_focus" implies SendInput() API, and does not | |
| // therefore require persistent hover. Likewise, not using native events | |
| // requires no persistent hover either. | |
| input_manager_settings.enable_persistent_hover = false; | |
| } else { | |
| input_manager_settings.enable_persistent_hover = enable_persistent_hover.asBool(); | |
| } | |
| mutable_executor.input_manager()->Initialize(input_manager_settings); | |
| } | |
| Json::Value NewSessionCommandHandler::CreateReturnedCapabilities(const IECommandExecutor& executor) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::CreateReturnedCapabilities"; | |
| Json::Value capabilities; | |
| capabilities[BROWSER_NAME_CAPABILITY] = "internet explorer"; | |
| capabilities[BROWSER_VERSION_CAPABILITY] = std::to_string(static_cast<long long>(executor.browser_factory()->browser_version())); | |
| capabilities[PLATFORM_NAME_CAPABILITY] = "windows"; | |
| capabilities[ACCEPT_INSECURE_CERTS_CAPABILITY] = false; | |
| capabilities[PAGE_LOAD_STRATEGY_CAPABILITY] = executor.page_load_strategy(); | |
| capabilities[STRICT_FILE_INTERACTABILITY_CAPABILITY] = executor.use_strict_file_interactability(); | |
| capabilities[SET_WINDOW_RECT_CAPABILITY] = true; | |
| if (executor.unexpected_alert_behavior().size() > 0) { | |
| capabilities[UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY] = executor.unexpected_alert_behavior(); | |
| } else { | |
| capabilities[UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY] = DISMISS_AND_NOTIFY_UNEXPECTED_ALERTS; | |
| } | |
| Json::Value timeouts; | |
| timeouts[IMPLICIT_WAIT_TIMEOUT_NAME] = executor.implicit_wait_timeout(); | |
| timeouts[PAGE_LOAD_TIMEOUT_NAME] = executor.page_load_timeout(); | |
| long long script_timeout = executor.async_script_timeout(); | |
| if (script_timeout < 0) { | |
| timeouts[SCRIPT_TIMEOUT_NAME] = Json::Value::null; | |
| } else { | |
| timeouts[SCRIPT_TIMEOUT_NAME] = script_timeout; | |
| } | |
| capabilities[TIMEOUTS_CAPABILITY] = timeouts; | |
| Json::Value ie_options; | |
| ie_options[IGNORE_PROTECTED_MODE_CAPABILITY] = executor.browser_factory()->ignore_protected_mode_settings(); | |
| ie_options[IGNORE_ZOOM_SETTING_CAPABILITY] = executor.browser_factory()->ignore_zoom_setting(); | |
| ie_options[INITIAL_BROWSER_URL_CAPABILITY] = executor.browser_factory()->initial_browser_url(); | |
| ie_options[BROWSER_ATTACH_TIMEOUT_CAPABILITY] = executor.browser_factory()->browser_attach_timeout(); | |
| ie_options[BROWSER_COMMAND_LINE_SWITCHES_CAPABILITY] = executor.browser_factory()->browser_command_line_switches(); | |
| ie_options[FORCE_CREATE_PROCESS_API_CAPABILITY] = executor.browser_factory()->force_createprocess_api(); | |
| ie_options[ENSURE_CLEAN_SESSION_CAPABILITY] = executor.browser_factory()->clear_cache(); | |
| ie_options[IGNORE_PROCESS_MATCH] = executor.browser_factory()->ignore_process_match(); | |
| ie_options[NATIVE_EVENTS_CAPABILITY] = executor.input_manager()->enable_native_events(); | |
| ie_options[ENABLE_PERSISTENT_HOVER_CAPABILITY] = executor.input_manager()->use_persistent_hover(); | |
| ie_options[ELEMENT_SCROLL_BEHAVIOR_CAPABILITY] = executor.input_manager()->scroll_behavior(); | |
| ie_options[REQUIRE_WINDOW_FOCUS_CAPABILITY] = executor.input_manager()->require_window_focus(); | |
| ie_options[FILE_UPLOAD_DIALOG_TIMEOUT_CAPABILITY] = executor.file_upload_dialog_timeout(); | |
| ie_options[ATTACH_TO_EDGE_CHROME] = executor.is_edge_mode(); | |
| ie_options[EDGE_EXECUTABLE_PATH] = executor.edge_executable_path(); | |
| if (executor.proxy_manager()->is_proxy_set()) { | |
| ie_options[USE_PER_PROCESS_PROXY_CAPABILITY] = executor.proxy_manager()->use_per_process_proxy(); | |
| capabilities[PROXY_CAPABILITY] = executor.proxy_manager()->GetProxyAsJson(); | |
| } else { | |
| capabilities[PROXY_CAPABILITY] = Json::Value(Json::objectValue); | |
| } | |
| capabilities[IE_DRIVER_EXTENSIONS_CAPABILITY] = ie_options; | |
| return capabilities; | |
| } | |
| bool NewSessionCommandHandler::MatchCapabilities(const IECommandExecutor& executor, | |
| const Json::Value& merged_capabilities, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::MatchCapabilities"; | |
| std::vector<std::string> capability_names = merged_capabilities.getMemberNames(); | |
| std::vector<std::string>::const_iterator name_iterator = capability_names.begin(); | |
| for (; name_iterator != capability_names.end(); ++name_iterator) { | |
| std::string capability_name = *name_iterator; | |
| if (capability_name == BROWSER_NAME_CAPABILITY && | |
| merged_capabilities[BROWSER_NAME_CAPABILITY].asString() != "internet explorer") { | |
| *error_message = "browserName must be 'internet explorer', but was '" + | |
| merged_capabilities[BROWSER_NAME_CAPABILITY].asString() + | |
| "'"; | |
| return false; | |
| } | |
| if (capability_name == PLATFORM_NAME_CAPABILITY && | |
| merged_capabilities[PLATFORM_NAME_CAPABILITY].asString() != "windows") { | |
| *error_message = "platformName must be 'windows', but was '" + | |
| merged_capabilities[PLATFORM_NAME_CAPABILITY].asString() + | |
| "'"; | |
| return false; | |
| } | |
| if (capability_name == BROWSER_VERSION_CAPABILITY) { | |
| // TODO: Support string version comparisons with '<', '>', '<=', and '>=' | |
| std::string requested_browser_version_value = merged_capabilities[BROWSER_VERSION_CAPABILITY].asString(); | |
| int available_browser_version = executor.browser_factory()->browser_version(); | |
| int requested_browser_version = atoi(requested_browser_version_value.c_str()); | |
| if (available_browser_version != requested_browser_version) { | |
| *error_message = "requested browserVersion value was '" + | |
| requested_browser_version_value + | |
| "', but the installed version of IE is " + | |
| std::to_string(available_browser_version) + | |
| " (note: only exact matches on major version " + | |
| "number are supported)"; | |
| return false; | |
| } | |
| } | |
| if (capability_name == ACCEPT_INSECURE_CERTS_CAPABILITY && | |
| merged_capabilities[ACCEPT_INSECURE_CERTS_CAPABILITY].asBool()) { | |
| *error_message = "acceptInsecureCerts was 'true', but the IE driver does not allow bypassing insecure (self-signed) SSL certificates"; | |
| return false; | |
| } | |
| if (capability_name.find(":") != std::string::npos && | |
| (capability_name != IE_DRIVER_EXTENSIONS_CAPABILITY && | |
| capability_name.find("test:") == std::string::npos)) { | |
| *error_message = capability_name + " is an unknown extension capability for IE"; | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| bool NewSessionCommandHandler::MergeCapabilities( | |
| const Json::Value& primary_capabilities, | |
| const Json::Value& secondary_capabilities, | |
| Json::Value* merged_capabilities, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::MergeCapabilities"; | |
| std::vector<std::string> primary_property_names = primary_capabilities.getMemberNames(); | |
| for (size_t i = 0; i < primary_property_names.size(); ++i) { | |
| std::string property_name = primary_property_names[i]; | |
| (*merged_capabilities)[property_name] = primary_capabilities[property_name]; | |
| } | |
| std::vector<std::string> secondary_property_names = secondary_capabilities.getMemberNames(); | |
| for (size_t i = 0; i < secondary_property_names.size(); ++i) { | |
| std::string property_name = secondary_property_names[i]; | |
| if (merged_capabilities->isMember(property_name)) { | |
| *error_message = "Cannot merge capabilities: " + | |
| property_name + " is already specified"; | |
| return false; | |
| } | |
| (*merged_capabilities)[property_name] = secondary_capabilities[property_name]; | |
| } | |
| return true; | |
| } | |
| bool NewSessionCommandHandler::ValidateCapabilities( | |
| const Json::Value& capabilities, | |
| const std::string& capability_set_name, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering NewSessionCommandHandler::ValidateCapabilities"; | |
| LOG(DEBUG) << "Validating capabilities object"; | |
| if (!capabilities.isObject() && !capabilities.isNull()) { | |
| *error_message = capability_set_name + " is not a JSON object."; | |
| return false; | |
| } | |
| if (capabilities.isNull()) { | |
| return true; | |
| } | |
| std::vector<std::string> capability_names = capabilities.getMemberNames(); | |
| std::vector<std::string>::const_iterator name_iterator = capability_names.begin(); | |
| for (; name_iterator != capability_names.end(); ++name_iterator) { | |
| std::string capability_name = *name_iterator; | |
| std::string capability_error_message; | |
| if (capabilities[capability_name].isNull()) { | |
| // Cast away the const modifier only in this case. | |
| const_cast<Json::Value&>(capabilities).removeMember(capability_name); | |
| continue; | |
| } | |
| if (capability_name == ACCEPT_INSECURE_CERTS_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << ACCEPT_INSECURE_CERTS_CAPABILITY << " capability." | |
| << " Validating value type is boolean."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::booleanValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name == STRICT_FILE_INTERACTABILITY_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << STRICT_FILE_INTERACTABILITY_CAPABILITY << " capability." | |
| << " Validating value type is boolean."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::booleanValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name == BROWSER_NAME_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << BROWSER_NAME_CAPABILITY << " capability." | |
| << " Validating value type is string."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::stringValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name == BROWSER_VERSION_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << BROWSER_VERSION_CAPABILITY << " capability." | |
| << " Validating value type is string."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::stringValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name == PLATFORM_NAME_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << PLATFORM_NAME_CAPABILITY << " capability." | |
| << " Validating value type is string."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::stringValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name == UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY << " capability." | |
| << " Validating value type is string."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::stringValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } else { | |
| LOG(DEBUG) << "Validating " << UNHANDLED_PROMPT_BEHAVIOR_CAPABILITY << " capability" | |
| << " is a valid value."; | |
| std::string unhandled_prompt_behavior = capabilities[capability_name].asString(); | |
| if (unhandled_prompt_behavior != ACCEPT_UNEXPECTED_ALERTS && | |
| unhandled_prompt_behavior != DISMISS_UNEXPECTED_ALERTS && | |
| unhandled_prompt_behavior != ACCEPT_AND_NOTIFY_UNEXPECTED_ALERTS && | |
| unhandled_prompt_behavior != DISMISS_AND_NOTIFY_UNEXPECTED_ALERTS && | |
| unhandled_prompt_behavior != IGNORE_UNEXPECTED_ALERTS) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "unhandledPromptBehavior is " + | |
| unhandled_prompt_behavior + | |
| " but must be 'accept' or 'dismiss'"; | |
| return false; | |
| } | |
| } | |
| continue; | |
| } | |
| if (capability_name == PAGE_LOAD_STRATEGY_CAPABILITY) { | |
| std::string page_load_strategy = ""; | |
| LOG(DEBUG) << "Found " << PAGE_LOAD_STRATEGY_CAPABILITY << " capability." | |
| << " Validating value type is string."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::stringValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } else { | |
| LOG(DEBUG) << "Validating " << PAGE_LOAD_STRATEGY_CAPABILITY << " capability" | |
| << " is a valid value."; | |
| page_load_strategy = capabilities[capability_name].asString(); | |
| if (page_load_strategy != NONE_PAGE_LOAD_STRATEGY && | |
| page_load_strategy != EAGER_PAGE_LOAD_STRATEGY && | |
| page_load_strategy != NORMAL_PAGE_LOAD_STRATEGY) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "pageLoadStrategy is " + page_load_strategy + | |
| " but must be 'none', 'eager', or 'normal'"; | |
| return false; | |
| } | |
| } | |
| continue; | |
| } | |
| if (capability_name == TIMEOUTS_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << TIMEOUTS_CAPABILITY << " capability." | |
| << " Validating value type is object."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::objectValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + capability_error_message; | |
| return false; | |
| } else { | |
| LOG(DEBUG) << "Validating " << TIMEOUTS_CAPABILITY << " capability" | |
| << " object contains correct property names."; | |
| Json::Value timeouts = capabilities[capability_name]; | |
| std::vector<std::string> timeout_names = timeouts.getMemberNames(); | |
| std::vector<std::string>::const_iterator timeout_name_iterator = timeout_names.begin(); | |
| for (; timeout_name_iterator != timeout_names.end(); ++timeout_name_iterator) { | |
| std::string timeout_name = *timeout_name_iterator; | |
| if (timeout_name != PAGE_LOAD_TIMEOUT_NAME && | |
| timeout_name != IMPLICIT_WAIT_TIMEOUT_NAME && | |
| timeout_name != SCRIPT_TIMEOUT_NAME) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "a timeout named " + timeout_name + | |
| " is specified, but timeout names must be " + | |
| "'implicit', 'pageLoad', or 'script'"; | |
| return false; | |
| } | |
| std::string timeout_error = ""; | |
| Json::Value timeout_value = timeouts[timeout_name]; | |
| // Special case: script timeout may be null. | |
| if (timeout_name != SCRIPT_TIMEOUT_NAME || !timeout_value.isNull()) { | |
| if (!timeout_value.isNumeric() || !timeout_value.isIntegral()) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "timeout " + timeout_name + | |
| "must be an integer"; | |
| return false; | |
| } | |
| if (!timeout_value.isInt64()) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "timeout " + timeout_name + | |
| "must be an integer between 0 and 2^53 - 1"; | |
| return false; | |
| } | |
| long long timeout = timeout_value.asInt64(); | |
| if (timeout < 0 || timeout > MAX_SAFE_INTEGER) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "timeout " + timeout_name + | |
| "must be an integer between 0 and 2^53 - 1"; | |
| return false; | |
| } | |
| } | |
| } | |
| } | |
| continue; | |
| } | |
| if (capability_name == PROXY_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << PROXY_CAPABILITY << " capability." | |
| << " Validating value type is object."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::objectValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| capability_error_message; | |
| return false; | |
| } else { | |
| LOG(DEBUG) << "Validating " << PROXY_CAPABILITY << "capability" | |
| << " object structure."; | |
| Json::Value proxy = capabilities[capability_name]; | |
| std::vector<std::string> proxy_setting_names = proxy.getMemberNames(); | |
| std::vector<std::string>::const_iterator proxy_setting_iterator = proxy_setting_names.begin(); | |
| for (; proxy_setting_iterator != proxy_setting_names.end(); ++proxy_setting_iterator) { | |
| std::string proxy_error = ""; | |
| std::string proxy_setting = *proxy_setting_iterator; | |
| if (proxy_setting == "proxyType") { | |
| if (!this->ValidateCapabilityType(proxy, | |
| proxy_setting, | |
| Json::ValueType::stringValue, | |
| &proxy_error)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "proxy setting " + proxy_error; | |
| return false; | |
| } | |
| std::string proxy_type = proxy[proxy_setting].asString(); | |
| if (proxy_type != "pac" && | |
| proxy_type != "direct" && | |
| proxy_type != "autodetect" && | |
| proxy_type != "system" && | |
| proxy_type != "manual") { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "a proxy type named " + proxy_type + | |
| " is specified, but proxy type must be " + | |
| "'pac', 'direct', 'autodetect', 'system', " + | |
| "or 'manual'"; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (proxy_setting == "proxyAutoconfigUrl" || | |
| proxy_setting == "ftpProxy" || | |
| proxy_setting == "httpProxy" || | |
| proxy_setting == "sslProxy" || | |
| proxy_setting == "socksProxy") { | |
| if (!this->ValidateCapabilityType(proxy, | |
| proxy_setting, | |
| Json::ValueType::stringValue, | |
| &proxy_error)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "proxy setting " + proxy_error; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (proxy_setting == "noProxy") { | |
| if (!this->ValidateCapabilityType(proxy, | |
| proxy_setting, | |
| Json::ValueType::arrayValue, | |
| &proxy_error)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "proxy setting " + proxy_error; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (proxy_setting == "socksVersion") { | |
| if (!this->ValidateCapabilityType(proxy, proxy_setting, | |
| Json::ValueType::intValue, | |
| &proxy_error)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "proxy setting " + proxy_error; | |
| return false; | |
| } | |
| int socks_version = proxy[proxy_setting].asInt(); | |
| if (socks_version < 0 || socks_version > 255) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "SOCKS version must be between 0 and 255."; | |
| return false; | |
| } | |
| continue; | |
| } | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| "unknown proxy setting named " + proxy_error; | |
| return false; | |
| } | |
| } | |
| continue; | |
| } | |
| if (capability_name == IE_DRIVER_EXTENSIONS_CAPABILITY) { | |
| LOG(DEBUG) << "Found " << IE_DRIVER_EXTENSIONS_CAPABILITY << " capability." | |
| << " Validating value type is object."; | |
| if (!this->ValidateCapabilityType(capabilities, | |
| capability_name, | |
| Json::ValueType::objectValue, | |
| &capability_error_message)) { | |
| *error_message = "Invalid capabilities in " + | |
| capability_set_name + ": " + | |
| capability_error_message; | |
| return false; | |
| } | |
| continue; | |
| } | |
| if (capability_name.find(":") != std::string::npos) { | |
| LOG(DEBUG) << "Found extension capability named " << capability_name << "." | |
| << " Nothing further to validate."; | |
| continue; | |
| } | |
| *error_message = "Invalid capabilities in " + capability_set_name + ": " + | |
| "unknown capability named " + capability_name; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool NewSessionCommandHandler::ValidateCapabilityType( | |
| const Json::Value& capabilities, | |
| const std::string& capability_name, | |
| const Json::ValueType& expected_capability_type, | |
| std::string* error_message) { | |
| Json::Value capability_value = capabilities[capability_name]; | |
| if (!this->IsEquivalentType(capability_value.type(), | |
| expected_capability_type)) { | |
| *error_message = capability_name + " is type " + | |
| this->GetJsonTypeDescription(capability_value.type()) + | |
| " instead of " + | |
| this->GetJsonTypeDescription(expected_capability_type); | |
| return false; | |
| } | |
| return true; | |
| } | |
| } // namespace webdriver |