[chromedriver] Allow commands to be async.

chrome/test/chromedriver/session_commands.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/session_commands.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"  // For CHECK macros.
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/basic_types.h"
 #include "chrome/test/chromedriver/chrome/automation_extension.h"
 #include "chrome/test/chromedriver/chrome/chrome.h"
 #include "chrome/test/chromedriver/chrome/geoposition.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/web_view.h"
 #include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/session.h"
-#include "chrome/test/chromedriver/session_map.h"
 #include "chrome/test/chromedriver/util.h"
 
 namespace {
 
 const char kWindowHandlePrefix[] = "CDwindow-";
 
 std::string WebViewIdToWindowHandle(const std::string& web_view_id) {
   return kWindowHandlePrefix + web_view_id;
 }
 
 bool WindowHandleToWebViewId(const std::string& window_handle,
                              std::string* web_view_id) {
   if (window_handle.find(kWindowHandlePrefix) != 0u)
     return false;
   *web_view_id = window_handle.substr(
       std::string(kWindowHandlePrefix).length());
   return true;
 }
 
-void ExecuteOnSessionThread(
-    const SessionCommand& command,
-    Session* session,
-    const base::DictionaryValue* params,
-    scoped_ptr<base::Value>* value,
-    Status* status,
-    base::WaitableEvent* event) {
-  *status = command.Run(session, *params, value);
-  event->Signal();
-}
-
 }  // namespace
 
-Status ExecuteSessionCommand(
-    SessionMap* session_map,
-    const SessionCommand& command,
+Status ExecuteQuit(
+    bool allow_detach,
+    Session* session,
     const base::DictionaryValue& params,
-    const std::string& session_id,
-    scoped_ptr<base::Value>* out_value,
-    std::string* out_session_id) {
-  *out_session_id = session_id;
-  scoped_refptr<SessionAccessor> session_accessor;
-  if (!session_map->Get(session_id, &session_accessor))
-    return Status(kNoSuchSession, session_id);
-  scoped_ptr<base::AutoLock> session_lock;
-  Session* session = session_accessor->Access(&session_lock);
-  if (!session)
-    return Status(kNoSuchSession, session_id);
-
-  Status status(kUnknownError);
-  base::WaitableEvent event(false, false);
-  session->thread.message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&ExecuteOnSessionThread, command, session,
-                 &params, out_value, &status, &event));
-  event.Wait();
-  if (status.IsError() && session->chrome)
-    status.AddDetails("Session info: chrome=" + session->chrome->GetVersion());
-  // Delete the session, because concurrent requests might hold a reference to
-  // the SessionAccessor already.
-  if (!session_map->Has(session_id))
-    session_accessor->DeleteSession();
-  return status;
+    scoped_ptr<base::Value>* value) {
+  if (allow_detach && session->detach) {
+    return Status(kOk);
+  } else {
+    session->quit = true;
+    return session->chrome->Quit();
+  }
 }
 
 Status ExecuteGetSessionCapabilities(
-    SessionMap* session_map,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
   value->reset(session->capabilities->DeepCopy());
   return Status(kOk);
 }
 
 Status ExecuteGetCurrentWindowHandle(
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
   WebView* web_view = NULL;
   Status status = session->GetTargetWindow(&web_view);
   if (status.IsError())
     return status;
 
   value->reset(new StringValue(WebViewIdToWindowHandle(web_view->GetId())));
   return Status(kOk);
 }
 
 Status ExecuteClose(
-    SessionMap* session_map,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
   std::list<std::string> web_view_ids;
   Status status = session->chrome->GetWebViewIds(&web_view_ids);
   if (status.IsError())
     return status;
   bool is_last_web_view = web_view_ids.size() == 1u;
   web_view_ids.clear();
 
   WebView* web_view = NULL;
   status = session->GetTargetWindow(&web_view);
   if (status.IsError())
     return status;
 
   status = session->chrome->CloseWebView(web_view->GetId());
   if (status.IsError())
     return status;
 
   status = session->chrome->GetWebViewIds(&web_view_ids);
   if ((status.code() == kChromeNotReachable && is_last_web_view) ||
       (status.IsOk() && web_view_ids.empty())) {
     // If no window is open, close is the equivalent of calling "quit".
-    CHECK(session_map->Remove(session->id));
+    session->quit = true;
     return session->chrome->Quit();
   }
 
   return status;
 }
 
 Status ExecuteGetWindowHandles(
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
@@ skipping 316 matching lines @@
   }
   std::string error_msg;
   base::FilePath upload;
   Status status = UnzipSoleFile(upload_dir, zip_data, &upload);
   if (status.IsError())
     return Status(kUnknownError, "unable to unzip 'file'", status);
 
   value->reset(new base::StringValue(upload.value()));
   return Status(kOk);
 }