// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/test/chromedriver/server/http_handler.h"

#include <stddef.h>

#include <memory>
#include <utility>

#include "base/bind.h"
#include "base/callback.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/logging.h"  // For CHECK macros.
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/sys_info.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/values.h"
#include "build/build_config.h"
#include "chrome/test/chromedriver/alert_commands.h"
#include "chrome/test/chromedriver/chrome/adb_impl.h"
#include "chrome/test/chromedriver/chrome/device_manager.h"
#include "chrome/test/chromedriver/chrome/status.h"
#include "chrome/test/chromedriver/net/port_server.h"
#include "chrome/test/chromedriver/net/url_request_context_getter.h"
#include "chrome/test/chromedriver/session.h"
#include "chrome/test/chromedriver/session_thread_map.h"
#include "chrome/test/chromedriver/util.h"
#include "chrome/test/chromedriver/version.h"
#include "net/server/http_server_request_info.h"
#include "net/server/http_server_response_info.h"
#include "url/url_util.h"

#if defined(OS_MACOSX)
#include "base/mac/scoped_nsautorelease_pool.h"
#endif

namespace {

const char kLocalStorage[] = "localStorage";
const char kSessionStorage[] = "sessionStorage";
const char kShutdownPath[] = "shutdown";

}  // namespace

CommandMapping::CommandMapping(HttpMethod method,
                               const std::string& path_pattern,
                               const Command& command)
    : method(method), path_pattern(path_pattern), command(command) {}

CommandMapping::CommandMapping(const CommandMapping& other) = default;

CommandMapping::~CommandMapping() {}

HttpHandler::HttpHandler(const std::string& url_base)
    : url_base_(url_base),
      received_shutdown_(false),
      command_map_(new CommandMap()),
      weak_ptr_factory_(this) {}

HttpHandler::HttpHandler(
    const base::Closure& quit_func,
    const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
    const std::string& url_base,
    int adb_port,
    std::unique_ptr<PortServer> port_server)
    : quit_func_(quit_func),
      url_base_(url_base),
      received_shutdown_(false),
      weak_ptr_factory_(this) {
#if defined(OS_MACOSX)
  base::mac::ScopedNSAutoreleasePool autorelease_pool;
#endif
  context_getter_ = new URLRequestContextGetter(io_task_runner);
  socket_factory_ = CreateSyncWebSocketFactory(context_getter_.get());
  adb_.reset(new AdbImpl(io_task_runner, adb_port));
  device_manager_.reset(new DeviceManager(adb_.get()));
  port_server_ = std::move(port_server);
  port_manager_.reset(new PortManager(12000, 13000));

  CommandMapping commands[] = {
      CommandMapping(
          kPost, internal::kNewSessionPathPattern,
          base::Bind(
              &ExecuteCreateSession, &session_thread_map_,
              WrapToCommand(
                  "InitSession",
                  base::Bind(&ExecuteInitSession,
                             InitSessionParams(context_getter_, socket_factory_,
                                               device_manager_.get(),
                                               port_server_.get(),
                                               port_manager_.get()))))),
      CommandMapping(
          kGet, "sessions",
          base::Bind(&ExecuteGetSessions,
                     WrapToCommand("GetSessions",
                                   base::Bind(&ExecuteGetSessionCapabilities)),
                     &session_thread_map_)),
      CommandMapping(kGet, "session/:sessionId",
                     WrapToCommand("GetSessionCapabilities",
                                   base::Bind(&ExecuteGetSessionCapabilities))),
      CommandMapping(kDelete, "session/:sessionId",
                     base::Bind(&ExecuteSessionCommand, &session_thread_map_,
                                "Quit", base::Bind(&ExecuteQuit, false), true)),
      CommandMapping(kGet, "session/:sessionId/window",
                     WrapToCommand("GetWindow",
                                   base::Bind(&ExecuteGetCurrentWindowHandle))),
      CommandMapping(kGet, "session/:sessionId/window_handle",
                     WrapToCommand("GetWindow",
                                   base::Bind(&ExecuteGetCurrentWindowHandle))),
      CommandMapping(
          kGet, "session/:sessionId/window/handles",
          WrapToCommand("GetWindows", base::Bind(&ExecuteGetWindowHandles))),
      CommandMapping(
          kGet, "session/:sessionId/window_handles",
          WrapToCommand("GetWindows", base::Bind(&ExecuteGetWindowHandles))),
      CommandMapping(kPost, "session/:sessionId/url",
                     WrapToCommand("Navigate", base::Bind(&ExecuteGet))),
      CommandMapping(kPost, "session/:sessionId/chromium/launch_app",
                     WrapToCommand("LaunchApp", base::Bind(&ExecuteLaunchApp))),
      CommandMapping(kGet, "session/:sessionId/alert",
                     WrapToCommand("IsAlertOpen",
                                   base::Bind(&ExecuteAlertCommand,
                                              base::Bind(&ExecuteGetAlert)))),
      CommandMapping(
          kPost, "session/:sessionId/alert/dismiss",
          WrapToCommand("DismissAlert",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteDismissAlert)))),
      CommandMapping(
          kPost, "session/:sessionId/dismiss_alert",
          WrapToCommand("DismissAlert",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteDismissAlert)))),
      CommandMapping(
          kPost, "session/:sessionId/alert/accept",
          WrapToCommand("AcceptAlert",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteAcceptAlert)))),
      CommandMapping(
          kPost, "session/:sessionId/accept_alert",
          WrapToCommand("AcceptAlert",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteAcceptAlert)))),
      CommandMapping(
          kGet, "session/:sessionId/alert/text",
          WrapToCommand("GetAlertMessage",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteGetAlertText)))),
      CommandMapping(
          kGet, "session/:sessionId/alert_text",
          WrapToCommand("GetAlertMessage",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteGetAlertText)))),
      CommandMapping(
          kPost, "session/:sessionId/alert/text",
          WrapToCommand("SetAlertPrompt",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteSetAlertText)))),
      CommandMapping(
          kPost, "session/:sessionId/alert_text",
          WrapToCommand("SetAlertPrompt",
                        base::Bind(&ExecuteAlertCommand,
                                   base::Bind(&ExecuteSetAlertText)))),
      CommandMapping(kPost, "session/:sessionId/forward",
                     WrapToCommand("GoForward", base::Bind(&ExecuteGoForward))),
      CommandMapping(kPost, "session/:sessionId/back",
                     WrapToCommand("GoBack", base::Bind(&ExecuteGoBack))),
      CommandMapping(kPost, "session/:sessionId/refresh",
                     WrapToCommand("Refresh", base::Bind(&ExecuteRefresh))),
      // still support old endpoints for executing scripts
      CommandMapping(
          kPost, "session/:sessionId/execute",
          WrapToCommand("ExecuteScript", base::Bind(&ExecuteExecuteScript))),
      CommandMapping(kPost, "session/:sessionId/execute_async",
                     WrapToCommand("ExecuteAsyncScript",
                                   base::Bind(&ExecuteExecuteAsyncScript))),
      CommandMapping(
          kPost, "session/:sessionId/execute/sync",
          WrapToCommand("ExecuteScript", base::Bind(&ExecuteExecuteScript))),
      CommandMapping(kPost, "session/:sessionId/execute/async",
                     WrapToCommand("ExecuteAsyncScript",
                                   base::Bind(&ExecuteExecuteAsyncScript))),
      CommandMapping(
          kGet, "session/:sessionId/url",
          WrapToCommand("GetUrl", base::Bind(&ExecuteGetCurrentUrl))),
      CommandMapping(kGet, "session/:sessionId/title",
                     WrapToCommand("GetTitle", base::Bind(&ExecuteGetTitle))),
      CommandMapping(
          kGet, "session/:sessionId/source",
          WrapToCommand("GetSource", base::Bind(&ExecuteGetPageSource))),
      CommandMapping(
          kGet, "session/:sessionId/screenshot",
          WrapToCommand("Screenshot", base::Bind(&ExecuteScreenshot))),
      CommandMapping(
          kGet, "session/:sessionId/chromium/heap_snapshot",
          WrapToCommand("HeapSnapshot", base::Bind(&ExecuteTakeHeapSnapshot))),
      CommandMapping(
          kPost, "session/:sessionId/visible",
          WrapToCommand("Visible", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kGet, "session/:sessionId/visible",
          WrapToCommand("Visible", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kPost, "session/:sessionId/element",
          WrapToCommand("FindElement", base::Bind(&ExecuteFindElement, 50))),
      CommandMapping(
          kPost, "session/:sessionId/elements",
          WrapToCommand("FindElements", base::Bind(&ExecuteFindElements, 50))),
      CommandMapping(kGet, "session/:sessionId/element/active",
                     WrapToCommand("GetActiveElement",
                                   base::Bind(&ExecuteGetActiveElement))),
      CommandMapping(kPost, "session/:sessionId/element/active",
                     WrapToCommand("GetActiveElement",
                                   base::Bind(&ExecuteGetActiveElement))),
      CommandMapping(kPost, "session/:sessionId/element/:id/element",
                     WrapToCommand("FindChildElement",
                                   base::Bind(&ExecuteFindChildElement, 50))),
      CommandMapping(kPost, "session/:sessionId/element/:id/elements",
                     WrapToCommand("FindChildElements",
                                   base::Bind(&ExecuteFindChildElements, 50))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/click",
          WrapToCommand("ClickElement", base::Bind(&ExecuteClickElement))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/clear",
          WrapToCommand("ClearElement", base::Bind(&ExecuteClearElement))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/submit",
          WrapToCommand("SubmitElement", base::Bind(&ExecuteSubmitElement))),
      CommandMapping(
          kGet, "session/:sessionId/element/:id/text",
          WrapToCommand("GetElementText", base::Bind(&ExecuteGetElementText))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/value",
          WrapToCommand("TypeElement", base::Bind(&ExecuteSendKeysToElement))),
      CommandMapping(
          kPost, "session/:sessionId/file",
          WrapToCommand("UploadFile", base::Bind(&ExecuteUploadFile))),
      CommandMapping(kGet, "session/:sessionId/element/:id/value",
                     WrapToCommand("GetElementValue",
                                   base::Bind(&ExecuteGetElementValue))),
      CommandMapping(kGet, "session/:sessionId/element/:id/name",
                     WrapToCommand("GetElementTagName",
                                   base::Bind(&ExecuteGetElementTagName))),
      CommandMapping(kGet, "session/:sessionId/element/:id/selected",
                     WrapToCommand("IsElementSelected",
                                   base::Bind(&ExecuteIsElementSelected))),
      CommandMapping(kGet, "session/:sessionId/element/:id/enabled",
                     WrapToCommand("IsElementEnabled",
                                   base::Bind(&ExecuteIsElementEnabled))),
      CommandMapping(kGet, "session/:sessionId/element/:id/displayed",
                     WrapToCommand("IsElementDisplayed",
                                   base::Bind(&ExecuteIsElementDisplayed))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/hover",
          WrapToCommand("HoverElement", base::Bind(&ExecuteHoverOverElement))),
      CommandMapping(kGet, "session/:sessionId/element/:id/location",
                     WrapToCommand("GetElementLocation",
                                   base::Bind(&ExecuteGetElementLocation))),
      CommandMapping(
          kGet, "session/:sessionId/element/:id/location_in_view",
          WrapToCommand(
              "GetElementLocationInView",
              base::Bind(&ExecuteGetElementLocationOnceScrolledIntoView))),
      CommandMapping(
          kGet, "session/:sessionId/element/:id/size",
          WrapToCommand("GetElementSize", base::Bind(&ExecuteGetElementSize))),
      CommandMapping(kGet, "session/:sessionId/element/:id/attribute/:name",
                     WrapToCommand("GetElementAttribute",
                                   base::Bind(&ExecuteGetElementAttribute))),
      CommandMapping(
          kGet, "session/:sessionId/element/:id/equals/:other",
          WrapToCommand("IsElementEqual", base::Bind(&ExecuteElementEquals))),
      CommandMapping(
          kGet, "session/:sessionId/cookie",
          WrapToCommand("GetCookies", base::Bind(&ExecuteGetCookies))),
      CommandMapping(
          kGet, "session/:sessionId/cookie/:name",
          WrapToCommand("GetNamedCookie", base::Bind(&ExecuteGetNamedCookie))),
      CommandMapping(kPost, "session/:sessionId/cookie",
                     WrapToCommand("AddCookie", base::Bind(&ExecuteAddCookie))),
      CommandMapping(kDelete, "session/:sessionId/cookie",
                     WrapToCommand("DeleteAllCookies",
                                   base::Bind(&ExecuteDeleteAllCookies))),
      CommandMapping(
          kDelete, "session/:sessionId/cookie/:name",
          WrapToCommand("DeleteCookie", base::Bind(&ExecuteDeleteCookie))),
      CommandMapping(
          kPost, "session/:sessionId/frame",
          WrapToCommand("SwitchToFrame", base::Bind(&ExecuteSwitchToFrame))),
      CommandMapping(kPost, "session/:sessionId/frame/parent",
                     WrapToCommand("SwitchToParentFrame",
                                   base::Bind(&ExecuteSwitchToParentFrame))),
      CommandMapping(
          kPost, "session/:sessionId/window",
          WrapToCommand("SwitchToWindow", base::Bind(&ExecuteSwitchToWindow))),
      CommandMapping(
          kGet, "session/:sessionId/window/rect",
          WrapToCommand("GetWindowRect", base::Bind(&ExecuteGetWindowRect))),
      CommandMapping(
          kGet, "session/:sessionId/window/:windowHandle/size",
          WrapToCommand("GetWindowSize", base::Bind(&ExecuteGetWindowSize))),
      CommandMapping(kGet, "session/:sessionId/window/:windowHandle/position",
                     WrapToCommand("GetWindowPosition",
                                   base::Bind(&ExecuteGetWindowPosition))),
      CommandMapping(
          kPost, "session/:sessionId/window/:windowHandle/size",
          WrapToCommand("SetWindowSize", base::Bind(&ExecuteSetWindowSize))),
      CommandMapping(kPost, "session/:sessionId/window/:windowHandle/position",
                     WrapToCommand("SetWindowPosition",
                                   base::Bind(&ExecuteSetWindowPosition))),
      CommandMapping(
          kPost, "session/:sessionId/window/:windowHandle/maximize",
          WrapToCommand("MaximizeWindow", base::Bind(&ExecuteMaximizeWindow))),
      CommandMapping(kPost, "session/:sessionId/window/fullscreen",
                     WrapToCommand("FullscreenWindow",
                                   base::Bind(&ExecuteFullScreenWindow))),
      CommandMapping(kDelete, "session/:sessionId/window",
                     WrapToCommand("CloseWindow", base::Bind(&ExecuteClose))),
      CommandMapping(
          kPost, "session/:sessionId/element/:id/drag",
          WrapToCommand("Drag", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kGet, "session/:sessionId/element/:id/css/:propertyName",
          WrapToCommand("GetElementCSSProperty",
                        base::Bind(&ExecuteGetElementValueOfCSSProperty))),
      CommandMapping(
          kPost, "session/:sessionId/timeouts/implicit_wait",
          WrapToCommand("SetImplicitWait", base::Bind(&ExecuteImplicitlyWait))),
      CommandMapping(kPost, "session/:sessionId/timeouts/async_script",
                     WrapToCommand("SetScriptTimeout",
                                   base::Bind(&ExecuteSetScriptTimeout))),
      CommandMapping(
          kPost, "session/:sessionId/timeouts",
          WrapToCommand("SetTimeout", base::Bind(&ExecuteSetTimeout))),
      CommandMapping(
          kGet, "session/:sessionId/timeouts",
          WrapToCommand("GetTimeouts", base::Bind(&ExecuteGetTimeouts))),
      CommandMapping(kPost, "session/:sessionId/execute_sql",
                     WrapToCommand("ExecuteSql",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kGet, "session/:sessionId/location",
          WrapToCommand("GetGeolocation", base::Bind(&ExecuteGetLocation))),
      CommandMapping(
          kPost, "session/:sessionId/location",
          WrapToCommand("SetGeolocation", base::Bind(&ExecuteSetLocation))),
      CommandMapping(kPost, "session/:sessionId/network_connection",
                     WrapToCommand("SetNetworkConnection",
                                   base::Bind(&ExecuteSetNetworkConnection))),
      CommandMapping(kGet, "session/:sessionId/network_connection",
                     WrapToCommand("GetNetworkConnection",
                                   base::Bind(&ExecuteGetNetworkConnection))),
      CommandMapping(kGet, "session/:sessionId/chromium/network_conditions",
                     WrapToCommand("GetNetworkConditions",
                                   base::Bind(&ExecuteGetNetworkConditions))),
      CommandMapping(kPost, "session/:sessionId/chromium/network_conditions",
                     WrapToCommand("SetNetworkConditions",
                                   base::Bind(&ExecuteSetNetworkConditions))),
      CommandMapping(
          kDelete, "session/:sessionId/chromium/network_conditions",
          WrapToCommand("DeleteNetworkConditions",
                        base::Bind(&ExecuteDeleteNetworkConditions))),
      CommandMapping(kGet, "session/:sessionId/application_cache/status",
                     base::Bind(&ExecuteGetStatus)),
      CommandMapping(kGet, "session/:sessionId/browser_connection",
                     WrapToCommand("GetBrowserConnection",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kPost, "session/:sessionId/browser_connection",
                     WrapToCommand("SetBrowserConnection",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kGet, "session/:sessionId/local_storage/key/:key",
          WrapToCommand("GetLocalStorageItem",
                        base::Bind(&ExecuteGetStorageItem, kLocalStorage))),
      CommandMapping(
          kDelete, "session/:sessionId/local_storage/key/:key",
          WrapToCommand("RemoveLocalStorageItem",
                        base::Bind(&ExecuteRemoveStorageItem, kLocalStorage))),
      CommandMapping(
          kGet, "session/:sessionId/local_storage",
          WrapToCommand("GetLocalStorageKeys",
                        base::Bind(&ExecuteGetStorageKeys, kLocalStorage))),
      CommandMapping(
          kPost, "session/:sessionId/local_storage",
          WrapToCommand("SetLocalStorageKeys",
                        base::Bind(&ExecuteSetStorageItem, kLocalStorage))),
      CommandMapping(
          kDelete, "session/:sessionId/local_storage",
          WrapToCommand("ClearLocalStorage",
                        base::Bind(&ExecuteClearStorage, kLocalStorage))),
      CommandMapping(
          kGet, "session/:sessionId/local_storage/size",
          WrapToCommand("GetLocalStorageSize",
                        base::Bind(&ExecuteGetStorageSize, kLocalStorage))),
      CommandMapping(
          kGet, "session/:sessionId/session_storage/key/:key",
          WrapToCommand("GetSessionStorageItem",
                        base::Bind(&ExecuteGetStorageItem, kSessionStorage))),
      CommandMapping(kDelete, "session/:sessionId/session_storage/key/:key",
                     WrapToCommand("RemoveSessionStorageItem",
                                   base::Bind(&ExecuteRemoveStorageItem,
                                              kSessionStorage))),
      CommandMapping(
          kGet, "session/:sessionId/session_storage",
          WrapToCommand("GetSessionStorageKeys",
                        base::Bind(&ExecuteGetStorageKeys, kSessionStorage))),
      CommandMapping(
          kPost, "session/:sessionId/session_storage",
          WrapToCommand("SetSessionStorageItem",
                        base::Bind(&ExecuteSetStorageItem, kSessionStorage))),
      CommandMapping(
          kDelete, "session/:sessionId/session_storage",
          WrapToCommand("ClearSessionStorage",
                        base::Bind(&ExecuteClearStorage, kSessionStorage))),
      CommandMapping(
          kGet, "session/:sessionId/session_storage/size",
          WrapToCommand("GetSessionStorageSize",
                        base::Bind(&ExecuteGetStorageSize, kSessionStorage))),
      CommandMapping(kGet, "session/:sessionId/orientation",
                     WrapToCommand("GetScreenOrientation",
                                   base::Bind(&ExecuteGetScreenOrientation))),
      CommandMapping(kPost, "session/:sessionId/orientation",
                     WrapToCommand("SetScreenOrientation",
                                   base::Bind(&ExecuteSetScreenOrientation))),
      CommandMapping(
          kDelete, "session/:sessionId/orientation",
          WrapToCommand("DeleteScreenOrientation",
                        base::Bind(&ExecuteDeleteScreenOrientation))),
      CommandMapping(kPost, "session/:sessionId/click",
                     WrapToCommand("Click", base::Bind(&ExecuteMouseClick))),
      CommandMapping(
          kPost, "session/:sessionId/doubleclick",
          WrapToCommand("DoubleClick", base::Bind(&ExecuteMouseDoubleClick))),
      CommandMapping(
          kPost, "session/:sessionId/buttondown",
          WrapToCommand("MouseDown", base::Bind(&ExecuteMouseButtonDown))),
      CommandMapping(
          kPost, "session/:sessionId/buttonup",
          WrapToCommand("MouseUp", base::Bind(&ExecuteMouseButtonUp))),
      CommandMapping(
          kPost, "session/:sessionId/moveto",
          WrapToCommand("MouseMove", base::Bind(&ExecuteMouseMoveTo))),
      CommandMapping(
          kPost, "session/:sessionId/keys",
          WrapToCommand("Type", base::Bind(&ExecuteSendKeysToActiveElement))),
      CommandMapping(kGet, "session/:sessionId/ime/available_engines",
                     WrapToCommand("GetAvailableEngines",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kGet, "session/:sessionId/ime/active_engine",
                     WrapToCommand("GetActiveEngine",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kGet, "session/:sessionId/ime/activated",
          WrapToCommand("Activated", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kPost, "session/:sessionId/ime/deactivate",
                     WrapToCommand("Deactivate",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kPost, "session/:sessionId/ime/activate",
          WrapToCommand("Activate", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kPost, "session/:sessionId/touch/click",
                     WrapToCommand("Tap", base::Bind(&ExecuteTouchSingleTap))),
      CommandMapping(kPost, "session/:sessionId/touch/down",
                     WrapToCommand("TouchDown", base::Bind(&ExecuteTouchDown))),
      CommandMapping(kPost, "session/:sessionId/touch/up",
                     WrapToCommand("TouchUp", base::Bind(&ExecuteTouchUp))),
      CommandMapping(kPost, "session/:sessionId/touch/move",
                     WrapToCommand("TouchMove", base::Bind(&ExecuteTouchMove))),
      CommandMapping(
          kPost, "session/:sessionId/touch/scroll",
          WrapToCommand("TouchScroll", base::Bind(&ExecuteTouchScroll))),
      CommandMapping(
          kPost, "session/:sessionId/touch/doubleclick",
          WrapToCommand("TouchDoubleTap", base::Bind(&ExecuteTouchDoubleTap))),
      CommandMapping(
          kPost, "session/:sessionId/touch/longclick",
          WrapToCommand("TouchLongPress", base::Bind(&ExecuteTouchLongPress))),
      CommandMapping(kPost, "session/:sessionId/touch/flick",
                     WrapToCommand("TouchFlick", base::Bind(&ExecuteFlick))),
      CommandMapping(kPost, "session/:sessionId/log",
                     WrapToCommand("GetLog", base::Bind(&ExecuteGetLog))),
      CommandMapping(kGet, "session/:sessionId/log/types",
                     WrapToCommand("GetLogTypes",
                                   base::Bind(&ExecuteGetAvailableLogTypes))),
      CommandMapping(kPost, "session/:sessionId/actions",
                     WrapToCommand("PerformActions",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kDelete, "session/:sessionId/actions",
                     WrapToCommand("DeleteActions",
                                   base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(
          kPost, "Logs",
          WrapToCommand("Logs", base::Bind(&ExecuteUnimplementedCommand))),
      CommandMapping(kGet, "status", base::Bind(&ExecuteGetStatus)),
      // Custom Chrome commands:
      // Allow quit all to be called with GET or POST.
      CommandMapping(
          kGet, kShutdownPath,
          base::Bind(&ExecuteQuitAll,
                     WrapToCommand("QuitAll", base::Bind(&ExecuteQuit, true)),
                     &session_thread_map_)),
      CommandMapping(
          kPost, kShutdownPath,
          base::Bind(&ExecuteQuitAll,
                     WrapToCommand("QuitAll", base::Bind(&ExecuteQuit, true)),
                     &session_thread_map_)),
      CommandMapping(kGet, "session/:sessionId/is_loading",
                     WrapToCommand("IsLoading", base::Bind(&ExecuteIsLoading))),
      CommandMapping(kGet, "session/:sessionId/autoreport",
                     WrapToCommand("IsAutoReporting",
                                   base::Bind(&ExecuteIsAutoReporting))),
      CommandMapping(kPost, "session/:sessionId/autoreport",
                     WrapToCommand("SetAutoReporting",
                                   base::Bind(&ExecuteSetAutoReporting))),
      CommandMapping(
          kPost, "session/:sessionId/touch/pinch",
          WrapToCommand("TouchPinch", base::Bind(&ExecuteTouchPinch))),
      CommandMapping(
          kPost, "session/:sessionId/chromium/send_command",
          WrapToCommand("SendCommand", base::Bind(&ExecuteSendCommand))),
      CommandMapping(
          kPost, "session/:sessionId/chromium/send_command_and_get_result",
          WrapToCommand("SendCommandAndGetResult",
                        base::Bind(&ExecuteSendCommandAndGetResult))),
  };
  command_map_.reset(
      new CommandMap(commands, commands + arraysize(commands)));
}

HttpHandler::~HttpHandler() {}

void HttpHandler::Handle(const net::HttpServerRequestInfo& request,
                         const HttpResponseSenderFunc& send_response_func) {
  CHECK(thread_checker_.CalledOnValidThread());

  if (received_shutdown_)
    return;

  std::string path = request.path;
  if (!base::StartsWith(path, url_base_, base::CompareCase::SENSITIVE)) {
    std::unique_ptr<net::HttpServerResponseInfo> response(
        new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
    response->SetBody("unhandled request", "text/plain");
    send_response_func.Run(std::move(response));
    return;
  }

  path.erase(0, url_base_.length());

  HandleCommand(request, path, send_response_func);

  if (path == kShutdownPath)
    received_shutdown_ = true;
}

Command HttpHandler::WrapToCommand(
    const char* name,
    const SessionCommand& session_command) {
  return base::Bind(&ExecuteSessionCommand,
                    &session_thread_map_,
                    name,
                    session_command,
                    false);
}

Command HttpHandler::WrapToCommand(
    const char* name,
    const WindowCommand& window_command) {
  return WrapToCommand(name, base::Bind(&ExecuteWindowCommand, window_command));
}

Command HttpHandler::WrapToCommand(
    const char* name,
    const ElementCommand& element_command) {
  return WrapToCommand(name,
                       base::Bind(&ExecuteElementCommand, element_command));
}

void HttpHandler::HandleCommand(
    const net::HttpServerRequestInfo& request,
    const std::string& trimmed_path,
    const HttpResponseSenderFunc& send_response_func) {
  base::DictionaryValue params;
  std::string session_id;
  CommandMap::const_iterator iter = command_map_->begin();
  while (true) {
    if (iter == command_map_->end()) {
      std::unique_ptr<net::HttpServerResponseInfo> response(
          new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      response->SetBody("unknown command: " + trimmed_path, "text/plain");
      send_response_func.Run(std::move(response));
      return;
    }
    if (internal::MatchesCommand(
            request.method, trimmed_path, *iter, &session_id, &params)) {
      break;
    }
    ++iter;
  }

  if (request.data.length()) {
    base::DictionaryValue* body_params;
    std::unique_ptr<base::Value> parsed_body =
        base::JSONReader::Read(request.data);
    if (!parsed_body || !parsed_body->GetAsDictionary(&body_params)) {
      std::unique_ptr<net::HttpServerResponseInfo> response(
          new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      response->SetBody("missing command parameters", "text/plain");
      send_response_func.Run(std::move(response));
      return;
    }
    params.MergeDictionary(body_params);
  }

  iter->command.Run(params,
                    session_id,
                    base::Bind(&HttpHandler::PrepareResponse,
                               weak_ptr_factory_.GetWeakPtr(),
                               trimmed_path,
                               send_response_func));
}

void HttpHandler::PrepareResponse(
    const std::string& trimmed_path,
    const HttpResponseSenderFunc& send_response_func,
    const Status& status,
    std::unique_ptr<base::Value> value,
    const std::string& session_id,
    bool w3c_compliant) {
  CHECK(thread_checker_.CalledOnValidThread());
  std::unique_ptr<net::HttpServerResponseInfo> response;
  if (w3c_compliant)
    response = PrepareStandardResponse(
        trimmed_path, status, std::move(value), session_id);
  else
    response = PrepareLegacyResponse(trimmed_path,
                                     status,
                                     std::move(value),
                                     session_id);
  send_response_func.Run(std::move(response));
  if (trimmed_path == kShutdownPath)
    quit_func_.Run();
}

std::unique_ptr<net::HttpServerResponseInfo> HttpHandler::PrepareLegacyResponse(
    const std::string& trimmed_path,
    const Status& status,
    std::unique_ptr<base::Value> value,
    const std::string& session_id) {
  if (status.code() == kUnknownCommand) {
    std::unique_ptr<net::HttpServerResponseInfo> response(
        new net::HttpServerResponseInfo(net::HTTP_NOT_IMPLEMENTED));
    response->SetBody("unimplemented command: " + trimmed_path, "text/plain");
    return response;
  }

  if (status.IsError()) {
    Status full_status(status);
    full_status.AddDetails(base::StringPrintf(
        "Driver info: chromedriver=%s,platform=%s %s %s",
        kChromeDriverVersion,
        base::SysInfo::OperatingSystemName().c_str(),
        base::SysInfo::OperatingSystemVersion().c_str(),
        base::SysInfo::OperatingSystemArchitecture().c_str()));
    std::unique_ptr<base::DictionaryValue> error(new base::DictionaryValue());
    error->SetString("message", full_status.message());
    value = std::move(error);
  }
  if (!value)
    value = base::MakeUnique<base::Value>();

  base::DictionaryValue body_params;
  body_params.SetInteger("status", status.code());
  body_params.Set("value", std::move(value));
  body_params.SetString("sessionId", session_id);
  std::string body;
  base::JSONWriter::WriteWithOptions(
      body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
      &body);
  std::unique_ptr<net::HttpServerResponseInfo> response(
      new net::HttpServerResponseInfo(net::HTTP_OK));
  response->SetBody(body, "application/json; charset=utf-8");
  return response;
}

std::unique_ptr<net::HttpServerResponseInfo>
HttpHandler::PrepareStandardResponse(
    const std::string& trimmed_path,
    const Status& status,
    std::unique_ptr<base::Value> value,
    const std::string& session_id) {
  std::unique_ptr<net::HttpServerResponseInfo> response;
  switch (status.code()) {
    case kOk:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_OK));
      break;
    // error codes
    case kElementNotInteractable:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kInvalidArgument:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kInvalidCookieDomain:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kInvalidElementState:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kInvalidSelector:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kJavaScriptError:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kNoSuchCookie:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kNoSuchElement:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kNoSuchFrame:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kNoSuchWindow:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kScriptTimeout:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_REQUEST_TIMEOUT));
      break;
    case kSessionNotCreatedException:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;
    case kStaleElementReference:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kTimeout:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_REQUEST_TIMEOUT));
      break;
    case kUnableToSetCookie:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;
    case kUnexpectedAlertOpen:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;
    case kUnknownCommand:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
      break;
    case kUnknownError:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;
    case kUnsupportedOperation:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;

    // TODO(kereliuk): evaluate the usage of these as they relate to the spec
    case kElementNotVisible:
    case kXPathLookupError:
    case kNoAlertOpen:
    case kNoSuchExecutionContext:
      response.reset(new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
      break;
    case kNoSuchSession:
    case kChromeNotReachable:
    case kDisconnected:
    case kForbidden:
    case kTabCrashed:
      response.reset(
          new net::HttpServerResponseInfo(net::HTTP_INTERNAL_SERVER_ERROR));
      break;
  }

  if (!value)
    value = base::MakeUnique<base::Value>();

  base::DictionaryValue body_params;
  if (status.IsError()){
    // Separates status default message from additional details.
    std::vector<std::string> status_details = base::SplitString(
        status.message(), ":\n", base::TRIM_WHITESPACE,
        base::SPLIT_WANT_NONEMPTY);
    std::string message;
    for (size_t i=1; i<status_details.size();++i)
      message += status_details[i];
    std::unique_ptr<base::DictionaryValue> inner_params(
        new base::DictionaryValue());
    inner_params->SetString("error", status_details[0]);
    inner_params->SetString("message", message);
    inner_params->SetString("stacktrace", status.stack_trace());
    body_params.SetDictionary("value", std::move(inner_params));
  } else {
    body_params.Set("value", std::move(value));
  }

  std::string body;
  base::JSONWriter::WriteWithOptions(
      body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
      &body);
  response->SetBody(body, "application/json; charset=utf-8");
  return response;
}


namespace internal {

const char kNewSessionPathPattern[] = "session";

bool MatchesMethod(HttpMethod command_method, const std::string& method) {
  std::string lower_method = base::ToLowerASCII(method);
  switch (command_method) {
    case kGet:
      return lower_method == "get";
    case kPost:
      return lower_method == "post" || lower_method == "put";
    case kDelete:
      return lower_method == "delete";
  }
  return false;
}

bool MatchesCommand(const std::string& method,
                    const std::string& path,
                    const CommandMapping& command,
                    std::string* session_id,
                    base::DictionaryValue* out_params) {
  if (!MatchesMethod(command.method, method))
    return false;

  std::vector<std::string> path_parts = base::SplitString(
      path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  std::vector<std::string> command_path_parts = base::SplitString(
      command.path_pattern, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  if (path_parts.size() != command_path_parts.size())
    return false;

  base::DictionaryValue params;
  for (size_t i = 0; i < path_parts.size(); ++i) {
    CHECK(command_path_parts[i].length());
    if (command_path_parts[i][0] == ':') {
      std::string name = command_path_parts[i];
      name.erase(0, 1);
      CHECK(name.length());
      url::RawCanonOutputT<base::char16> output;
      url::DecodeURLEscapeSequences(
          path_parts[i].data(), path_parts[i].length(), &output);
      std::string decoded = base::UTF16ToASCII(
          base::string16(output.data(), output.length()));
      // Due to crbug.com/533361, the url decoding libraries decodes all of the
      // % escape sequences except for %%. We need to handle this case manually.
      // So, replacing all the instances of "%%" with "%".
      base::ReplaceSubstringsAfterOffset(&decoded, 0 , "%%" , "%");
      if (name == "sessionId")
        *session_id = decoded;
      else
        params.SetString(name, decoded);
    } else if (command_path_parts[i] != path_parts[i]) {
      return false;
    }
  }
  out_params->MergeDictionary(&params);
  return true;
}

}  // namespace internal