[chromedriver] Remove dll build target.

chrome/test/chromedriver/server/http_handler.cc

 // 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 "base/bind.h"
+#include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/sys_info.h"
 #include "base/values.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/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
-#include "chrome/test/chromedriver/command_executor.h"
-#include "chrome/test/chromedriver/command_names.h"
+#include "chrome/test/chromedriver/chrome/version.h"
+#include "chrome/test/chromedriver/commands.h"
+#include "chrome/test/chromedriver/element_commands.h"
+#include "chrome/test/chromedriver/net/url_request_context_getter.h"
 #include "chrome/test/chromedriver/server/http_response.h"
+#include "chrome/test/chromedriver/session.h"
+#include "chrome/test/chromedriver/session_commands.h"
+#include "chrome/test/chromedriver/session_map.h"
 #include "chrome/test/chromedriver/util.h"
+#include "chrome/test/chromedriver/window_commands.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";
 
+Status UnimplementedCommand(
+    const base::DictionaryValue& params,
+    const std::string& session_id,
+    scoped_ptr<base::Value>* value,
+    std::string* out_session_id) {
+  return Status(kUnknownCommand);
+}
+
 }  // namespace
 
 HttpRequest::HttpRequest(HttpMethod method,
                          const std::string& path,
                          const std::string& body)
     : method(method), path(path), body(body) {}
 
 HttpRequest::~HttpRequest() {}
 
+CommandMapping::CommandMapping() {}

[chrisgao (Use stgao instead), 2013/07/02 01:31:40]

remove

[chrisgao (Use stgao instead), 2013/07/02 18:13:04]

Done.

+
 CommandMapping::CommandMapping(HttpMethod method,
                                const std::string& path_pattern,
-                               const std::string& name)
-    : method(method), path_pattern(path_pattern), name(name) {}
+                               const Command& command)
+    : method(method), path_pattern(path_pattern), command(command) {}
 
 CommandMapping::~CommandMapping() {}
 
-// static
-scoped_ptr<HttpHandler::CommandMap> HttpHandler::CreateCommandMap() {
+HttpHandler::HttpHandler(Log* log, const std::string& url_base)
+    : log_(log),
+      io_thread_("ChromeDriver IO"),
+      url_base_(url_base) {
+}
+
+HttpHandler::~HttpHandler() {}
+
+void HttpHandler::Init() {
+#if defined(OS_MACOSX)
+  base::mac::ScopedNSAutoreleasePool autorelease_pool;
+#endif
+  base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
+  CHECK(io_thread_.StartWithOptions(options));
+  context_getter_ = new URLRequestContextGetter(
+      io_thread_.message_loop_proxy());
+  socket_factory_ = CreateSyncWebSocketFactory(context_getter_.get());
+  adb_.reset(new AdbImpl(io_thread_.message_loop_proxy(), log_));
+  device_manager_.reset(new DeviceManager(adb_.get()));
+
   CommandMapping commands[] = {
-      CommandMapping(kPost, "session", CommandNames::kNewSession),
+      CommandMapping(kPost, internal::kNewSessionPathPattern,
+                     base::Bind(&ExecuteNewSession,
+                                NewSessionParams(log_, &session_map_,
+                                    context_getter_, socket_factory_,
+                                    device_manager_.get()))),
       CommandMapping(kGet, "session/:sessionId",
-                     CommandNames::kGetSessionCapabilities),
-      CommandMapping(kDelete, "session/:sessionId", CommandNames::kQuit),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetSessionCapabilities,
+                             &session_map_))),
+      CommandMapping(kDelete, "session/:sessionId",
+                     base::Bind(&ExecuteQuit, false, &session_map_)),
       CommandMapping(kGet, "session/:sessionId/window_handle",
-                     CommandNames::kGetCurrentWindowHandle),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetCurrentWindowHandle))),
       CommandMapping(kGet, "session/:sessionId/window_handles",
-                     CommandNames::kGetWindowHandles),
-      CommandMapping(kPost, "session/:sessionId/url", CommandNames::kGet),
-      CommandMapping(kGet, "session/:sessionId/alert", CommandNames::kGetAlert),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetWindowHandles))),
+      CommandMapping(kPost, "session/:sessionId/url",
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGet))),
+      CommandMapping(kGet, "session/:sessionId/alert",
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetAlert))),
       CommandMapping(kPost, "session/:sessionId/dismiss_alert",
-                     CommandNames::kDismissAlert),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteDismissAlert))),
       CommandMapping(kPost, "session/:sessionId/accept_alert",
-                     CommandNames::kAcceptAlert),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteAcceptAlert))),
       CommandMapping(kGet, "session/:sessionId/alert_text",
-                     CommandNames::kGetAlertText),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetAlertText))),

[kkania, 2013/07/02 01:57:08]

alert stuff should use ExecuteAlertCommand

[chrisgao (Use stgao instead), 2013/07/02 18:13:04]

Done.

       CommandMapping(kPost, "session/:sessionId/alert_text",
-                     CommandNames::kSetAlertValue),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetAlertValue))),
       CommandMapping(kPost, "session/:sessionId/forward",
-                     CommandNames::kGoForward),
-      CommandMapping(kPost, "session/:sessionId/back", CommandNames::kGoBack),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGoForward))),
+      CommandMapping(kPost, "session/:sessionId/back",
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGoBack))),
       CommandMapping(kPost, "session/:sessionId/refresh",
-                     CommandNames::kRefresh),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteRefresh))),
       CommandMapping(kPost, "session/:sessionId/execute",
-                     CommandNames::kExecuteScript),
+                     WrapToNonSessionCommand(base::Bind(
+                         &ExecuteExecuteScript))),
       CommandMapping(kPost, "session/:sessionId/execute_async",
-                     CommandNames::kExecuteAsyncScript),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteExecuteAsyncScript))),
       CommandMapping(kGet, "session/:sessionId/url",
-                     CommandNames::kGetCurrentUrl),
-      CommandMapping(kGet, "session/:sessionId/title", CommandNames::kGetTitle),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetCurrentUrl))),
+      CommandMapping(kGet, "session/:sessionId/title",
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetTitle))),
       CommandMapping(kGet, "session/:sessionId/source",
-                     CommandNames::kGetPageSource),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetPageSource))),
       CommandMapping(kGet, "session/:sessionId/screenshot",
-                     CommandNames::kScreenshot),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteScreenshot))),
       CommandMapping(kPost, "session/:sessionId/visible",
-                     CommandNames::kSetBrowserVisible),
+                     base::Bind(&UnimplementedCommand)),

[chrisgao (Use stgao instead), 2013/07/02 01:31:40]

Remove unimplemented command mappings or add a stub?

[chrisgao (Use stgao instead), 2013/07/02 18:13:04]

Done.

       CommandMapping(kGet, "session/:sessionId/visible",
-                     CommandNames::kIsBrowserVisible),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/element",
-                     CommandNames::kFindElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteFindElement, 50))),
       CommandMapping(kPost, "session/:sessionId/elements",
-                     CommandNames::kFindElements),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteFindElements, 50))),
       CommandMapping(kPost, "session/:sessionId/element/active",
-                     CommandNames::kGetActiveElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetActiveElement))),
       CommandMapping(kPost, "session/:sessionId/element/:id/element",
-                     CommandNames::kFindChildElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteFindChildElement, 50))),
       CommandMapping(kPost, "session/:sessionId/element/:id/elements",
-                     CommandNames::kFindChildElements),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteFindChildElements, 50))),
       CommandMapping(kPost, "session/:sessionId/element/:id/click",
-                     CommandNames::kClickElement),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteClickElement))),
       CommandMapping(kPost, "session/:sessionId/element/:id/clear",
-                     CommandNames::kClearElement),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteClearElement))),
       CommandMapping(kPost, "session/:sessionId/element/:id/submit",
-                     CommandNames::kSubmitElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSubmitElement))),
       CommandMapping(kGet, "session/:sessionId/element/:id/text",
-                     CommandNames::kGetElementText),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementText))),
       CommandMapping(kPost, "session/:sessionId/element/:id/value",
-                     CommandNames::kSendKeysToElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSendKeysToElement))),
       CommandMapping(kPost, "session/:sessionId/file",
-                     CommandNames::kUploadFile),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteUploadFile))),
       CommandMapping(kGet, "session/:sessionId/element/:id/value",
-                     CommandNames::kGetElementValue),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementValue))),
       CommandMapping(kGet, "session/:sessionId/element/:id/name",
-                     CommandNames::kGetElementTagName),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementTagName))),
       CommandMapping(kGet, "session/:sessionId/element/:id/selected",
-                     CommandNames::kIsElementSelected),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteIsElementSelected))),
       CommandMapping(kGet, "session/:sessionId/element/:id/enabled",
-                     CommandNames::kIsElementEnabled),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteIsElementEnabled))),
       CommandMapping(kGet, "session/:sessionId/element/:id/displayed",
-                     CommandNames::kIsElementDisplayed),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteIsElementDisplayed))),
       CommandMapping(kPost, "session/:sessionId/element/:id/hover",
-                     CommandNames::kHoverOverElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteHoverOverElement))),
       CommandMapping(kGet, "session/:sessionId/element/:id/location",
-                     CommandNames::kGetElementLocation),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementLocation))),
       CommandMapping(kGet, "session/:sessionId/element/:id/location_in_view",
-                     CommandNames::kGetElementLocationOnceScrolledIntoView),
+                     WrapToNonSessionCommand(
+                         base::Bind(
+                             &ExecuteGetElementLocationOnceScrolledIntoView))),
       CommandMapping(kGet, "session/:sessionId/element/:id/size",
-                     CommandNames::kGetElementSize),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementSize))),
       CommandMapping(kGet, "session/:sessionId/element/:id/attribute/:name",
-                     CommandNames::kGetElementAttribute),
+                     WrapToNonSessionCommand(
+                          base::Bind(&ExecuteGetElementAttribute))),
       CommandMapping(kGet, "session/:sessionId/element/:id/equals/:other",
-                     CommandNames::kElementEquals),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteElementEquals))),
       CommandMapping(kGet, "session/:sessionId/cookie",
-                     CommandNames::kGetCookies),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetCookies))),
       CommandMapping(kPost, "session/:sessionId/cookie",
-                     CommandNames::kAddCookie),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteAddCookie))),
       CommandMapping(kDelete, "session/:sessionId/cookie",
-                     CommandNames::kDeleteAllCookies),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteDeleteAllCookies))),
       CommandMapping(kDelete, "session/:sessionId/cookie/:name",
-                     CommandNames::kDeleteCookie),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteDeleteCookie))),
       CommandMapping(kPost, "session/:sessionId/frame",
-                     CommandNames::kSwitchToFrame),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSwitchToFrame))),
       CommandMapping(kPost, "session/:sessionId/window",
-                     CommandNames::kSwitchToWindow),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSwitchToWindow))),
       CommandMapping(kGet, "session/:sessionId/window/:windowHandle/size",
-                     CommandNames::kGetWindowSize),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetWindowSize))),
       CommandMapping(kGet, "session/:sessionId/window/:windowHandle/position",
-                     CommandNames::kGetWindowPosition),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetWindowPosition))),
       CommandMapping(kPost, "session/:sessionId/window/:windowHandle/size",
-                     CommandNames::kSetWindowSize),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetWindowSize))),
       CommandMapping(kPost, "session/:sessionId/window/:windowHandle/position",
-                     CommandNames::kSetWindowPosition),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetWindowPosition))),
       CommandMapping(kPost, "session/:sessionId/window/:windowHandle/maximize",
-                     CommandNames::kMaximizeWindow),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteMaximizeWindow))),
       CommandMapping(kDelete, "session/:sessionId/window",
-                     CommandNames::kClose),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteClose, &session_map_))),
       CommandMapping(kPost, "session/:sessionId/element/:id/drag",
-                     CommandNames::kDragElement),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kGet, "session/:sessionId/element/:id/css/:propertyName",
-                     CommandNames::kGetElementValueOfCssProperty),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetElementValueOfCSSProperty))),
       CommandMapping(kPost, "session/:sessionId/timeouts/implicit_wait",
-                     CommandNames::kImplicitlyWait),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteImplicitlyWait))),
       CommandMapping(kPost, "session/:sessionId/timeouts/async_script",
-                     CommandNames::kSetScriptTimeout),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetScriptTimeout))),
       CommandMapping(kPost, "session/:sessionId/timeouts",
-                     CommandNames::kSetTimeout),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteSetTimeout))),
       CommandMapping(kPost, "session/:sessionId/execute_sql",
-                     CommandNames::kExecuteSQL),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kGet, "session/:sessionId/location",
-                     CommandNames::kGetLocation),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetLocation))),
       CommandMapping(kPost, "session/:sessionId/location",
-                     CommandNames::kSetLocation),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteSetLocation))),
       CommandMapping(kGet, "session/:sessionId/application_cache/status",
-                     CommandNames::kGetStatus),
+                     base::Bind(&ExecuteGetStatus)),
       CommandMapping(kGet, "session/:sessionId/browser_connection",
-                     CommandNames::kIsBrowserOnline),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/browser_connection",
-                     CommandNames::kSetBrowserOnline),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kGet, "session/:sessionId/local_storage/key/:key",
-                     CommandNames::kGetLocalStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageItem, kLocalStorage))),
       CommandMapping(kDelete, "session/:sessionId/local_storage/key/:key",
-                     CommandNames::kRemoveLocalStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteRemoveStorageItem, kLocalStorage))),
       CommandMapping(kGet, "session/:sessionId/local_storage",
-                     CommandNames::kGetLocalStorageKeys),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageKeys, kLocalStorage))),
       CommandMapping(kPost, "session/:sessionId/local_storage",
-                     CommandNames::kSetLocalStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetStorageItem, kLocalStorage))),
       CommandMapping(kDelete, "session/:sessionId/local_storage",
-                     CommandNames::kClearLocalStorage),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteClearStorage, kLocalStorage))),
       CommandMapping(kGet, "session/:sessionId/local_storage/size",
-                     CommandNames::kGetLocalStorageSize),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageSize, kLocalStorage))),
       CommandMapping(kGet, "session/:sessionId/session_storage/key/:key",
-                     CommandNames::kGetSessionStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageItem, kSessionStorage))),
       CommandMapping(kDelete, "session/:sessionId/session_storage/key/:key",
-                     CommandNames::kRemoveSessionStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(
+                             &ExecuteRemoveStorageItem, kSessionStorage))),
       CommandMapping(kGet, "session/:sessionId/session_storage",
-                     CommandNames::kGetSessionStorageKey),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageKeys, kSessionStorage))),
       CommandMapping(kPost, "session/:sessionId/session_storage",
-                     CommandNames::kSetSessionStorageItem),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSetStorageItem, kSessionStorage))),
       CommandMapping(kDelete, "session/:sessionId/session_storage",
-                     CommandNames::kClearSessionStorage),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteClearStorage, kSessionStorage))),
       CommandMapping(kGet, "session/:sessionId/session_storage/size",
-                     CommandNames::kGetSessionStorageSize),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetStorageSize, kSessionStorage))),
       CommandMapping(kGet, "session/:sessionId/orientation",
-                     CommandNames::kGetScreenOrientation),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/orientation",
-                     CommandNames::kSetScreenOrientation),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/click",
-                     CommandNames::kMouseClick),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteMouseClick))),
       CommandMapping(kPost, "session/:sessionId/doubleclick",
-                     CommandNames::kMouseDoubleClick),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteMouseDoubleClick))),
       CommandMapping(kPost, "session/:sessionId/buttondown",
-                     CommandNames::kMouseButtonDown),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteMouseButtonDown))),
       CommandMapping(kPost, "session/:sessionId/buttonup",
-                     CommandNames::kMouseButtonUp),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteMouseButtonUp))),
       CommandMapping(kPost, "session/:sessionId/moveto",
-                     CommandNames::kMouseMoveTo),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteMouseMoveTo))),
       CommandMapping(kPost, "session/:sessionId/keys",
-                     CommandNames::kSendKeysToActiveElement),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteSendKeysToActiveElement))),
       CommandMapping(kGet, "session/:sessionId/ime/available_engines",
-                     CommandNames::kImeGetAvailableEngines),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kGet, "session/:sessionId/ime/active_engine",
-                     CommandNames::kImeGetActiveEngine),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kGet, "session/:sessionId/ime/activated",
-                     CommandNames::kImeIsActivated),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/ime/deactivate",
-                     CommandNames::kImeDeactivate),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/ime/activate",
-                     CommandNames::kImeActivateEngine),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/click",
-                     CommandNames::kTouchSingleTap),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteTouchSingleTap))),
       CommandMapping(kPost, "session/:sessionId/touch/down",
-                     CommandNames::kTouchDown),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/up",
-                     CommandNames::kTouchUp),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/move",
-                     CommandNames::kTouchMove),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/scroll",
-                     CommandNames::kTouchScroll),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/doubleclick",
-                     CommandNames::kTouchDoubleTap),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/longclick",
-                     CommandNames::kTouchLongPress),
+                     base::Bind(&UnimplementedCommand)),
       CommandMapping(kPost, "session/:sessionId/touch/flick",
-                     CommandNames::kTouchFlick),
-      CommandMapping(kPost, "session/:sessionId/log", CommandNames::kGetLog),
+                     base::Bind(&UnimplementedCommand)),
+      CommandMapping(kPost, "session/:sessionId/log",
+                     WrapToNonSessionCommand(base::Bind(&ExecuteGetLog))),
       CommandMapping(kGet, "session/:sessionId/log/types",
-                     CommandNames::kGetAvailableLogTypes),
-      CommandMapping(kPost, "logs", CommandNames::kGetSessionLogs),
-      CommandMapping(kGet, "status", CommandNames::kStatus),
+                     WrapToNonSessionCommand(
+                         base::Bind(&ExecuteGetAvailableLogTypes))),
+      CommandMapping(kPost, "logs", base::Bind(&UnimplementedCommand)),
+      CommandMapping(kGet, "status", base::Bind(&ExecuteGetStatus)),
 
       // Custom Chrome commands:
       // Allow quit all to be called with GET or POST.
-      CommandMapping(kGet, kShutdownPath, CommandNames::kQuitAll),
-      CommandMapping(kPost, kShutdownPath, CommandNames::kQuitAll),
+      CommandMapping(kGet, kShutdownPath,
+                     base::Bind(&ExecuteQuitAll,
+                                base::Bind(&ExecuteQuit, true, &session_map_),
+                                &session_map_)),
+      CommandMapping(kPost, kShutdownPath,
+                     base::Bind(&ExecuteQuitAll,
+                                base::Bind(&ExecuteQuit, true, &session_map_),
+                                &session_map_)),
       CommandMapping(kGet, "session/:sessionId/is_loading",
-                     CommandNames::kIsLoading),
+                     WrapToNonSessionCommand(base::Bind(&ExecuteIsLoading))),
   };
-  return scoped_ptr<CommandMap>(
+  this->command_map_ = scoped_ptr<CommandMap>(

[kkania, 2013/07/02 01:57:08]

command_map_.reset(new CommandMap(commands, commands + arraysize(commands));

[chrisgao (Use stgao instead), 2013/07/02 18:13:04]

Done.

       new CommandMap(commands, commands + arraysize(commands)));
 }
 
-HttpHandler::HttpHandler(Log* log,
-                         scoped_ptr<CommandExecutor> executor,
-                         scoped_ptr<CommandMap> command_map,
-                         const std::string& url_base)
-    : log_(log),
-      executor_(executor.Pass()),
-      command_map_(command_map.Pass()),
-      url_base_(url_base) {
-  executor_->Init();
-}
-
-HttpHandler::~HttpHandler() {}
-
 void HttpHandler::Handle(const HttpRequest& request,
                          HttpResponse* response) {
   const char* method = "GET";
   if (request.method == kPost)
     method = "POST";
   else if (request.method == kDelete)
     method = "DELETE";
   log_->AddEntry(
       Log::kLog,
       base::StringPrintf("received WebDriver request: %s %s %s",
                          method,
                          request.path.c_str(),
                          request.body.c_str()));
 
   HandleInternal(request, response);
 
   log_->AddEntry(
       Log::kLog,
       base::StringPrintf("sending WebDriver response: %d %s",
                          response->status(),
                          response->body().c_str()));
 }
 
 bool HttpHandler::ShouldShutdown(const HttpRequest& request) {
   return request.path == url_base_ + kShutdownPath;
 }
 
+Command HttpHandler::WrapToNonSessionCommand(

[kkania, 2013/07/02 01:57:08]

How about just call these WrapToCommand?

[chrisgao (Use stgao instead), 2013/07/02 18:13:04]

Done.

+    const SessionCommand& session_command) {
+  return base::Bind(&ExecuteSessionCommand, &session_map_, session_command);
+}
+
+Command HttpHandler::WrapToNonSessionCommand(
+    const WindowCommand& window_command) {
+  return WrapToNonSessionCommand(
+      base::Bind(&ExecuteWindowCommand, window_command));
+}
+
+Command HttpHandler::WrapToNonSessionCommand(
+    const ElementCommand& element_command) {
+  return WrapToNonSessionCommand(
+      base::Bind(&ExecuteElementCommand, element_command));
+}
+
 void HttpHandler::HandleInternal(const HttpRequest& request,
                                  HttpResponse* response) {
   std::string path = request.path;
   if (!StartsWithASCII(path, url_base_, true)) {
     *response = HttpResponse(HttpResponse::kBadRequest);
     response->set_body("unhandled request");
     return;
   }
 
   path.erase(0, url_base_.length());
@@ skipping 27 matching lines @@
     base::DictionaryValue* body_params;
     scoped_ptr<base::Value> parsed_body(base::JSONReader::Read(request.body));
     if (!parsed_body || !parsed_body->GetAsDictionary(&body_params)) {
       *response = HttpResponse(HttpResponse::kBadRequest);
       response->set_body("missing command parameters");
       return true;
     }
     params.MergeDictionary(body_params);
   }
 
-  StatusCode status = kOk;
   scoped_ptr<base::Value> value;
   std::string out_session_id;
-  executor_->ExecuteCommand(
-      iter->name, params, session_id, &status, &value, &out_session_id);
+  Status status = iter->command.Run(
+      params, session_id, &value, &out_session_id);
 
-  if (status == kUnknownCommand) {
+  if (status.code() == kUnknownCommand) {
     *response = HttpResponse(HttpResponse::kNotImplemented);
-    response->set_body("unimplemented command: " + iter->name);
+    response->set_body("unimplemented command: " + trimmed_path);
     return true;
   }
 
-  if (iter->name == CommandNames::kNewSession && status == kOk) {
+  if (iter->path_pattern == internal::kNewSessionPathPattern && status.IsOk()) {
     // Creating a session involves a HTTP request to /session, which is
     // supposed to redirect to /session/:sessionId, which returns the
     // session info.
     *response = HttpResponse(HttpResponse::kSeeOther);
     response->AddHeader("Location", url_base_ + "session/" + out_session_id);
     return true;
+  } else if (status.IsError()) {
+    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()));
+    scoped_ptr<base::DictionaryValue> error(new base::DictionaryValue());
+    error->SetString("message", status.message());
+    value.reset(error.release());
   }
+  if (!value)
+    value.reset(base::Value::CreateNullValue());
 
   base::DictionaryValue body_params;
-  body_params.SetInteger("status", status);
+  body_params.SetInteger("status", status.code());
   body_params.Set("value", value.release());
   body_params.SetString("sessionId", out_session_id);
   std::string body;
   base::JSONWriter::WriteWithOptions(
       &body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &body);
   *response = HttpResponse(HttpResponse::kOk);
   response->SetMimeType("application/json; charset=utf-8");
   response->set_body(body);
   return true;
 }
 
 namespace internal {
 
+const char kNewSessionPathPattern[] = "session";
+
 bool MatchesCommand(HttpMethod method,
                     const std::string& path,
                     const CommandMapping& command,
                     std::string* session_id,
                     base::DictionaryValue* out_params) {
   if (method != command.method)
     return false;
 
   std::vector<std::string> path_parts;
   base::SplitString(path, '/', &path_parts);
@@ skipping 14 matching lines @@
       else
         params.SetString(name, path_parts[i]);
     } else if (command_path_parts[i] != path_parts[i]) {
       return false;
     }
   }
   out_params->MergeDictionary(&params);
   return true;
 }
 
-}  // namespace
+}  // namespace internal