| // Copyright 2015 The Cobalt Authors. All Rights Reserved. |
| // |
| // Licensed 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. |
| |
| #ifndef COBALT_WEBDRIVER_UTIL_DISPATCH_COMMAND_FACTORY_H_ |
| #define COBALT_WEBDRIVER_UTIL_DISPATCH_COMMAND_FACTORY_H_ |
| |
| #include <algorithm> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/callback.h" |
| #include "base/memory/ptr_util.h" |
| |
| namespace cobalt { |
| namespace webdriver { |
| namespace util { |
| namespace internal { |
| namespace { |
| template <typename T> |
| struct ForwardType { |
| typedef const T& value; |
| }; |
| |
| template <typename T> |
| struct ForwardType<T&> { |
| typedef T& value; |
| }; |
| |
| template <typename T, size_t n> |
| struct ForwardType<T[n]> { |
| typedef const T* value; |
| }; |
| |
| // See comment for CallbackParamTraits<T[n]>. |
| template <typename T> |
| struct ForwardType<T[]> { |
| typedef const T* value; |
| }; |
| |
| // unique_ptr-like move-only types. |
| template <typename T> |
| struct ForwardType<std::unique_ptr<T>> { |
| typedef std::unique_ptr<T> value; |
| }; |
| } // namespace |
| |
| // Convert a value to a base::Value to return it as a part of the WebDriver |
| // response object. |
| template <typename T> |
| std::unique_ptr<base::Value> ToValue(const T& value) { |
| return T::ToValue(value); |
| } |
| |
| template <typename T> |
| std::unique_ptr<base::Value> ToValue(const std::vector<T>& value) { |
| std::unique_ptr<base::ListValue> list_value(new base::ListValue()); |
| for (int i = 0; i < value.size(); ++i) { |
| list_value->Append(std::move(ToValue<T>(value[i]))); |
| } |
| return std::unique_ptr<base::Value>(list_value.release()); |
| } |
| |
| // Partial template specialization for base::optional. |
| template <typename T> |
| std::unique_ptr<base::Value> ToValue(const base::Optional<T>& value) { |
| if (value) { |
| return ToValue<T>(*value); |
| } else { |
| return std::make_unique<base::Value>(); |
| } |
| } |
| |
| // Template specialization for std::string. |
| template <> |
| std::unique_ptr<base::Value> ToValue(const std::string& value) { |
| return std::unique_ptr<base::Value>(new base::Value(value)); |
| } |
| |
| // Template specialization for bool. |
| template <> |
| std::unique_ptr<base::Value> ToValue(const bool& value) { |
| return std::unique_ptr<base::Value>(new base::Value(value)); |
| } |
| |
| template <typename R> |
| std::unique_ptr<base::Value> ToValue(const CommandResult<R>& command_result) { |
| return ToValue(command_result.result()); |
| } |
| |
| template <> |
| std::unique_ptr<base::Value> ToValue( |
| const CommandResult<void>& command_result) { |
| return std::make_unique<base::Value>(); |
| } |
| |
| // Convert a base::Value to a base::Optional<T>. If value could not be converted |
| // base::nullopt will be returned. |
| template <typename T> |
| base::Optional<T> FromValue(const base::Value* value) { |
| return T::FromValue(value); |
| } |
| |
| template <> |
| base::Optional<GURL> FromValue(const base::Value* value) { |
| const char kUrlKey[] = "url"; |
| std::string url; |
| const base::DictionaryValue* dictionary_value; |
| if (!value->GetAsDictionary(&dictionary_value) || |
| !dictionary_value->GetString(kUrlKey, &url)) { |
| return base::nullopt; |
| } |
| return GURL(url.c_str()); |
| } |
| |
| // Returns an appropriate response through the CommandResultHandler. |
| // On failure, the error response value is created and on success the |
| // result in the CommandResult instance is converted to a base::Value and |
| // returned. |
| template <typename R> |
| void ReturnResponse(const base::Optional<protocol::SessionId>& session_id, |
| const util::CommandResult<R>& command_result, |
| WebDriverDispatcher::CommandResultHandler* result_handler) { |
| std::unique_ptr<base::Value> result; |
| if (command_result.is_success()) { |
| result = internal::ToValue(command_result); |
| } else { |
| result = |
| protocol::Response::CreateErrorResponse(command_result.error_message()); |
| } |
| result_handler->SendResult(session_id, command_result.status_code(), |
| std::move(result)); |
| } |
| |
| } // namespace internal |
| |
| // Helper class to create WebDriverDispatcher::DispatchCommandCallbacks that |
| // can be used with the WebDriverDispatcher::RegisterCommand function. |
| // Specify the XXXDriver class name as a template parameter. |
| template <class DriverClassT> |
| class DispatchCommandFactory |
| : public base::RefCounted<DispatchCommandFactory<DriverClassT>> { |
| // Max retries for the "can_retry" CommandResult case. |
| static const int kMaxRetries = 5; |
| |
| public: |
| // Typedef'd for less verbose code. |
| typedef WebDriverDispatcher::CommandResultHandler CommandResultHandler; |
| typedef WebDriverDispatcher::DispatchCommandCallback DispatchCommandCallback; |
| typedef WebDriverDispatcher::PathVariableMap PathVariableMap; |
| |
| // Callback that takes PathVariableMap* and CommandResultHandler* as arguments |
| // and returns a SessionDriver*. |
| // Attempts to extract the sessionID from the PathVariableMap and finds the |
| // session that this ID maps to. If no such session occurs, an error is sent |
| // through the CommandResultHandler and NULL is returned. |
| typedef base::Callback<SessionDriver*(const PathVariableMap* path_variables, |
| CommandResultHandler*)> |
| GetSessionCommand; |
| |
| // Callback that takes PathVariableMap* and CommandResultHandler* as arguments |
| // and returns a DriverClass*. |
| // If necessary extracts the id from the PathVariableMap and finds the driver |
| // that this ID maps to. If no such driver occurs, an error is sent through |
| // the CommandResultHandler and NULL is returned. |
| typedef base::Callback<DriverClassT*(SessionDriver*, |
| const PathVariableMap* path_variables, |
| CommandResultHandler*)> |
| GetDriverCommand; |
| |
| // Takes GetSessionCommand and GetDriverCommand callbacks. These will be |
| // called when the DispatchCommandCallback is called to try to find the |
| // correct XXXDriver based on the path variables. |
| DispatchCommandFactory(const GetSessionCommand& get_session, |
| const GetDriverCommand& get_driver) |
| : get_session_(get_session), get_driver_(get_driver) {} |
| |
| // Returns a DispatchCommandCallback that will call the specified |
| // command_callback. |
| // If the path variables successfully map to a DriverClass instance, it will |
| // be passed as the argument to the command_callback. |
| // If no such DriverClass instance can be found, the command_callback will not |
| // be run. The results of the command will be sent through the |
| // CommandResultHandler. |
| template <typename R> |
| DispatchCommandCallback GetCommandHandler( |
| const base::Callback<util::CommandResult<R>(DriverClassT*)>& |
| command_callback) { |
| typedef CommandHandler<R> CommandHandler; |
| return CommandHandler::GetCommandHandler( |
| get_session_, get_driver_, |
| base::Bind(&CommandHandler::RunCommand, command_callback)); |
| } |
| |
| // Returns a DispatchCommandCallback that will call the specified |
| // command_callback with an argument. |
| // If the path variables successfully map to a DriverClass instance, it will |
| // be passed as the argument to the command_callback. |
| // If the parameters passed to the command cannot be converted to an instance |
| // of type A1, the command_callback will not be called an an appropriate |
| // error will be returned through the CommandRequestHandler. |
| // If no such DriverClass instance can be found, the command_callback will not |
| // be run. |
| template <typename R, typename A1> |
| DispatchCommandCallback GetCommandHandler( |
| const base::Callback<util::CommandResult<R>(DriverClassT*, const A1&)>& |
| command_callback) { |
| typedef CommandHandler<R> CommandHandler; |
| return CommandHandler::GetCommandHandler( |
| get_session_, get_driver_, |
| base::Bind(&CommandHandler::template ExtractParameterAndRunCommand<A1>, |
| command_callback)); |
| } |
| |
| private: |
| // Works with the DispatchCommandFactory to create a DispatchCommandCallback |
| // for a particular return value R. Putting this into a nested template class |
| // helps alleviate some of the headaches of working with C++ templates. |
| template <typename R> |
| class CommandHandler : public base::RefCounted<CommandHandler<R>> { |
| public: |
| // Wrapper around an actual command to run. It will extract arguments from |
| // |parameters| if necessary and pass them to the command. |
| // If parameters cannot be extracted, an appropriate error will be sent to |
| // the CommandResultHandler. |
| // Upon successful completion of the command, the result will be sent to |
| // CommandResultHandler. |
| typedef base::Callback<void( |
| const base::Optional<protocol::SessionId>&, DriverClassT* driver, |
| const base::Value* parameters, CommandResultHandler* result_handler)> |
| RunCommandCallback; |
| |
| typedef base::Callback<util::CommandResult<R>(DriverClassT*)> |
| DriverCommandFunction; |
| // After binding the first argument, this function signature matches that of |
| // RunCommandCallback. |
| // The first argument is a base::Callback that runs a DriverClassT member |
| // function with no parameters. |
| static void RunCommand( |
| const DriverCommandFunction& driver_command, |
| const base::Optional<protocol::SessionId>& session_id, |
| DriverClassT* driver, const base::Value* parameters, |
| CommandResultHandler* result_handler) { |
| // Ignore parameters. |
| int retries = 0; |
| util::CommandResult<R> command_result; |
| do { |
| command_result = driver_command.Run(driver); |
| } while (command_result.can_retry() && (retries++ < kMaxRetries)); |
| internal::ReturnResponse(session_id, command_result, result_handler); |
| } |
| |
| // After binding the first argument, this function signature matches that of |
| // RunCommandCallback. |
| // The first argument is a base::Callback that runs a DriverClassT member |
| // function with one parameter. |
| template <typename A1> |
| static void ExtractParameterAndRunCommand( |
| const base::Callback<util::CommandResult<R>( |
| DriverClassT*, typename internal::ForwardType<A1>::value)>& |
| driver_command, |
| const base::Optional<protocol::SessionId>& session_id, |
| DriverClassT* driver, const base::Value* parameters, |
| CommandResultHandler* result_handler) { |
| // Extract the parameter from |parameters|. If unsuccessful, return a |
| // kInvalidParameters error. Otherwise, pass the extracted parameter to |
| // the |driver_command|. |
| using A1_NO_REF = typename std::remove_reference<A1>::type; |
| base::Optional<A1_NO_REF> param = |
| internal::FromValue<A1_NO_REF>(parameters); |
| if (!param) { |
| result_handler->SendInvalidRequestResponse( |
| WebDriverDispatcher::CommandResultHandler::kInvalidParameters, ""); |
| } else { |
| int retries = 0; |
| util::CommandResult<R> command_result; |
| do { |
| command_result = driver_command.Run(driver, param.value()); |
| } while (command_result.can_retry() && (retries++ < kMaxRetries)); |
| internal::ReturnResponse(session_id, command_result, result_handler); |
| } |
| } |
| |
| // Create a new CommandHandler instance, and base::Bind to its HandleCommand |
| // function. |
| static DispatchCommandCallback GetCommandHandler( |
| const GetSessionCommand& get_session_command, |
| const GetDriverCommand& get_driver_command, |
| const RunCommandCallback& run_command_callback) { |
| scoped_refptr<CommandHandler> command_handler(new CommandHandler( |
| get_session_command, get_driver_command, run_command_callback)); |
| return base::Bind(&CommandHandler::HandleCommand, command_handler); |
| } |
| |
| private: |
| // Simple constructor that sets each of the necessary callbacks. |
| CommandHandler(const GetSessionCommand& get_session_callback, |
| const GetDriverCommand& get_driver_callback, |
| const RunCommandCallback& run_command_callback) |
| : get_session_(get_session_callback), |
| get_driver_(get_driver_callback), |
| run_command_(run_command_callback) {} |
| |
| // This function matches the WebDriverDispatcher::DispatchCommandCallback |
| // signature, and as such is appropriate to be passed to the |
| // WebDriverDispatcher::RegisterCommand function. |
| // Using the the callbacks stored in this CommandHandler, it will extract |
| // the appropriate XXXDriver, and execute |run_command_| on it. |
| void HandleCommand(const base::Value* value, |
| const PathVariableMap* path_variables, |
| std::unique_ptr<CommandResultHandler> result_handler) { |
| SessionDriver* session = |
| get_session_.Run(path_variables, result_handler.get()); |
| if (session) { |
| DriverClassT* driver = |
| get_driver_.Run(session, path_variables, result_handler.get()); |
| if (driver) { |
| run_command_.Run(session->session_id(), driver, value, |
| result_handler.get()); |
| } |
| } |
| } |
| |
| GetSessionCommand get_session_; |
| GetDriverCommand get_driver_; |
| RunCommandCallback run_command_; |
| }; |
| |
| GetSessionCommand get_session_; |
| GetDriverCommand get_driver_; |
| }; |
| |
| } // namespace util |
| } // namespace webdriver |
| } // namespace cobalt |
| |
| #endif // COBALT_WEBDRIVER_UTIL_DISPATCH_COMMAND_FACTORY_H_ |