blob: 35afd3ee9ebb14f1a7c3b7b7f1a0ca20305f3f49 [file] [log] [blame]
// 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_