chrome/test/chromedriver/commands.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/chromedriver/commands.h"
   6
   7 #include <algorithm>
   8 #include <list>
   9 #include <utility>
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/logging.h"
  14 #include "base/memory/linked_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/message_loop/message_loop_proxy.h"
  17 #include "base/run_loop.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/sys_info.h"
  20 #include "base/values.h"
  21 #include "chrome/test/chromedriver/capabilities.h"
  22 #include "chrome/test/chromedriver/chrome/browser_info.h"
  23 #include "chrome/test/chromedriver/chrome/chrome.h"
  24 #include "chrome/test/chromedriver/chrome/status.h"
  25 #include "chrome/test/chromedriver/logging.h"
  26 #include "chrome/test/chromedriver/session.h"
  27 #include "chrome/test/chromedriver/session_thread_map.h"
  28 #include "chrome/test/chromedriver/util.h"
  29
  30 void ExecuteGetStatus(
  31     const base::DictionaryValue& params,
  32     const std::string& session_id,
  33     const CommandCallback& callback) {
  34   base::DictionaryValue build;
  35   build.SetString("version", "alpha");
  36
  37   base::DictionaryValue os;
  38   os.SetString("name", base::SysInfo::OperatingSystemName());
  39   os.SetString("version", base::SysInfo::OperatingSystemVersion());
  40   os.SetString("arch", base::SysInfo::OperatingSystemArchitecture());
  41
  42   base::DictionaryValue info;
  43   info.Set("build", build.DeepCopy());
  44   info.Set("os", os.DeepCopy());
  45   callback.Run(
  46       Status(kOk), scoped_ptr<base::Value>(info.DeepCopy()), std::string());
  47 }
  48
  49 void ExecuteCreateSession(
  50     SessionThreadMap* session_thread_map,
  51     const Command& init_session_cmd,
  52     const base::DictionaryValue& params,
  53     const std::string& session_id,
  54     const CommandCallback& callback) {
  55   std::string new_id = session_id;
  56   if (new_id.empty())
  57     new_id = GenerateId();
  58   scoped_ptr<Session> session(new Session(new_id));
  59   scoped_ptr<base::Thread> thread(new base::Thread(new_id));
  60   if (!thread->Start()) {
  61     callback.Run(
  62         Status(kUnknownError, "failed to start a thread for the new session"),
  63         scoped_ptr<base::Value>(),
  64         std::string());
  65     return;
  66   }
  67
  68   thread->message_loop()->PostTask(
  69       FROM_HERE, base::Bind(&SetThreadLocalSession, base::Passed(&session)));
  70   session_thread_map
  71       ->insert(std::make_pair(new_id, make_linked_ptr(thread.release())));
  72   init_session_cmd.Run(params, new_id, callback);
  73 }
  74
  75 namespace {
  76
  77 void OnSessionQuit(const base::WeakPtr<size_t>& quit_remaining_count,
  78                    const base::Closure& all_quit_func,
  79                    const Status& status,
  80                    scoped_ptr<base::Value> value,
  81                    const std::string& session_id) {
  82   // |quit_remaining_count| may no longer be valid if a timeout occurred.
  83   if (!quit_remaining_count)
  84     return;
  85
  86   (*quit_remaining_count)--;
  87   if (!*quit_remaining_count)
  88     all_quit_func.Run();
  89 }
  90
  91 }  // namespace
  92
  93 void ExecuteQuitAll(
  94     const Command& quit_command,
  95     SessionThreadMap* session_thread_map,
  96     const base::DictionaryValue& params,
  97     const std::string& session_id,
  98     const CommandCallback& callback) {
  99   size_t quit_remaining_count = session_thread_map->size();
 100   base::WeakPtrFactory<size_t> weak_ptr_factory(&quit_remaining_count);
 101   if (!quit_remaining_count) {
 102     callback.Run(Status(kOk), scoped_ptr<base::Value>(), session_id);
 103     return;
 104   }
 105   base::RunLoop run_loop;
 106   for (SessionThreadMap::const_iterator iter = session_thread_map->begin();
 107        iter != session_thread_map->end();
 108        ++iter) {
 109     quit_command.Run(params,
 110                      iter->first,
 111                      base::Bind(&OnSessionQuit,
 112                                 weak_ptr_factory.GetWeakPtr(),
 113                                 run_loop.QuitClosure()));
 114   }
 115   base::MessageLoop::current()->PostDelayedTask(
 116       FROM_HERE, run_loop.QuitClosure(), base::TimeDelta::FromSeconds(10));
 117   // Uses a nested run loop to block this thread until all the quit
 118   // commands have executed, or the timeout expires.
 119   base::MessageLoop::current()->SetNestableTasksAllowed(true);
 120   run_loop.Run();
 121   callback.Run(Status(kOk), scoped_ptr<base::Value>(), session_id);
 122 }
 123
 124 namespace {
 125
 126 void TerminateSessionThreadOnCommandThread(SessionThreadMap* session_thread_map,
 127                                            const std::string& session_id) {
 128   session_thread_map->erase(session_id);
 129 }
 130
 131 void ExecuteSessionCommandOnSessionThread(
 132     const char* command_name,
 133     const SessionCommand& command,
 134     bool return_ok_without_session,
 135     scoped_ptr<base::DictionaryValue> params,
 136     scoped_refptr<base::SingleThreadTaskRunner> cmd_task_runner,
 137     const CommandCallback& callback_on_cmd,
 138     const base::Closure& terminate_on_cmd) {
 139   Session* session = GetThreadLocalSession();
 140   if (!session) {
 141     cmd_task_runner->PostTask(
 142         FROM_HERE,
 143         base::Bind(callback_on_cmd,
 144                    Status(return_ok_without_session ? kOk : kNoSuchSession),
 145                    base::Passed(scoped_ptr<base::Value>()),
 146                    std::string()));
 147     return;
 148   }
 149
 150   if (IsVLogOn(0)) {
 151     VLOG(0) << "COMMAND " << command_name << " "
 152             << FormatValueForDisplay(*params);
 153   }
 154
 155   // Notify |session|'s |CommandListener|s of the command.
 156   // Will mark |session| for deletion if an error is encountered.
 157   Status status = NotifyCommandListenersBeforeCommand(session, command_name);
 158
 159   // Only run the command if we were able to notify all listeners successfully.
 160   // Otherwise, pass error to callback, delete |session|, and do not continue.
 161   scoped_ptr<base::Value> value;
 162   if (status.IsError()) {
 163     LOG(ERROR) << status.message();
 164   } else {
 165     status = command.Run(session, *params, &value);
 166
 167     if (status.IsError() && session->chrome) {
 168       if (!session->quit && session->chrome->HasCrashedWebView()) {
 169         session->quit = true;
 170         std::string message("session deleted because of page crash");
 171         if (!session->detach) {
 172           Status quit_status = session->chrome->Quit();
 173           if (quit_status.IsError())
 174             message += ", but failed to kill browser:" + quit_status.message();
 175         }
 176         status = Status(kUnknownError, message, status);
 177       } else if (status.code() == kDisconnected) {
 178         // Some commands, like clicking a button or link which closes the
 179         // window, may result in a kDisconnected error code.
 180         std::list<std::string> web_view_ids;
 181         Status status_tmp = session->chrome->GetWebViewIds(&web_view_ids);
 182         if (status_tmp.IsError() && status_tmp.code() != kChromeNotReachable) {
 183           status.AddDetails(
 184               "failed to check if window was closed: " + status_tmp.message());
 185         } else if (std::find(web_view_ids.begin(),
 186                              web_view_ids.end(),
 187                              session->window) == web_view_ids.end()) {
 188           status = Status(kOk);
 189         }
 190       }
 191       if (status.IsError()) {
 192         const BrowserInfo* browser_info = session->chrome->GetBrowserInfo();
 193         status.AddDetails("Session info: " + browser_info->browser_name + "=" +
 194                           browser_info->browser_version);
 195       }
 196     }
 197
 198     if (IsVLogOn(0)) {
 199       std::string result;
 200       if (status.IsError()) {
 201         result = status.message();
 202       } else if (value) {
 203         result = FormatValueForDisplay(*value);
 204       }
 205       VLOG(0) << "RESPONSE " << command_name
 206               << (result.length() ? " " + result : "");
 207     }
 208
 209     if (status.IsOk() && session->auto_reporting_enabled) {
 210       std::string message = session->GetFirstBrowserError();
 211       if (!message.empty())
 212         status = Status(kUnknownError, message);
 213     }
 214   }
 215
 216   cmd_task_runner->PostTask(
 217       FROM_HERE,
 218       base::Bind(callback_on_cmd, status, base::Passed(&value), session->id));
 219
 220   if (session->quit) {
 221     SetThreadLocalSession(scoped_ptr<Session>());
 222     delete session;
 223     cmd_task_runner->PostTask(FROM_HERE, terminate_on_cmd);
 224   }
 225 }
 226
 227 }  // namespace
 228
 229 void ExecuteSessionCommand(
 230     SessionThreadMap* session_thread_map,
 231     const char* command_name,
 232     const SessionCommand& command,
 233     bool return_ok_without_session,
 234     const base::DictionaryValue& params,
 235     const std::string& session_id,
 236     const CommandCallback& callback) {
 237   SessionThreadMap::iterator iter = session_thread_map->find(session_id);
 238   if (iter == session_thread_map->end()) {
 239     Status status(return_ok_without_session ? kOk : kNoSuchSession);
 240     callback.Run(status, scoped_ptr<base::Value>(), session_id);
 241   } else {
 242     iter->second->message_loop()
 243         ->PostTask(FROM_HERE,
 244                    base::Bind(&ExecuteSessionCommandOnSessionThread,
 245                               command_name,
 246                               command,
 247                               return_ok_without_session,
 248                               base::Passed(make_scoped_ptr(params.DeepCopy())),
 249                               base::MessageLoopProxy::current(),
 250                               callback,
 251                               base::Bind(&TerminateSessionThreadOnCommandThread,
 252                                          session_thread_map,
 253                                          session_id)));
 254   }
 255 }
 256
 257 namespace internal {
 258
 259 void CreateSessionOnSessionThreadForTesting(const std::string& id) {
 260   SetThreadLocalSession(make_scoped_ptr(new Session(id)));
 261 }
 262
 263 }  // namespace internal