Add chrome.loadAsync capability to ChromeDriver, which allows the user not to

chrome/test/webdriver/session.cc

 // Copyright (c) 2011 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/webdriver/session.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 36 matching lines @@
     : window_id(window_id),
       frame_path(frame_path) {
 }
 
 FrameId& FrameId::operator=(const FrameId& other) {
   window_id = other.window_id;
   frame_path = other.frame_path;
   return *this;
 }
 
-Session::Session()
+Session::Options::Options()
+    : use_native_events(false),
+      load_async(false) {
+}
+
+Session::Options::~Options() {
+}
+
+Session::Session(const Options& options)
     : id_(GenerateRandomID()),
       current_target_(FrameId(0, FramePath())),
       thread_(id_.c_str()),
       async_script_timeout_(0),
       implicit_wait_(0),
-      screenshot_on_error_(false),
-      use_native_events_(false),
-      has_alert_prompt_text_(false) {
+      has_alert_prompt_text_(false),
+      options_(options) {
   SessionManager::GetInstance()->Add(this);
 }
 
 Session::~Session() {
   SessionManager::GetInstance()->Remove(id_);
 }
 
 Error* Session::Init(const FilePath& browser_exe,
                      const FilePath& user_data_dir,
                      const CommandLine& options) {
   if (!thread_.Start()) {
     delete this;
     return new Error(kUnknownError, "Cannot start session thread");
   }
 
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::InitOnSessionThread,
       browser_exe,
       user_data_dir,
       options,
       &error));
   if (error)
     Terminate();
   return error;
 }
 
+Error* Session::BeforeExecuteCommand() {
+  Error* error = NULL;
+  if (!options_.load_async) {
+    LOG(INFO) << "Waiting for the page to stop loading";
+    error = WaitForAllTabsToStopLoading();
+    LOG(INFO) << "Done waiting for the page to stop loading";
+  }
+  if (!error) {
+    error = SwitchToTopFrameIfCurrentFrameInvalid();
+  }
+  return error;
+}
+
 void Session::Terminate() {
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::TerminateOnSessionThread));
   delete this;
 }
 
 Error* Session::ExecuteScript(const FrameId& frame_id,
                               const std::string& script,
                               const ListValue* const args,
@@ skipping 117 matching lines @@
       &Automation::DragAndDropFilePaths,
       current_target_.window_id,
       location,
       paths,
       &error));
   return error;
 }
 
 Error* Session::NavigateToURL(const std::string& url) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
-      &Automation::NavigateToURL,
-      current_target_.window_id,
-      url,
-      &error));
+  if (options_.load_async) {
+    RunSessionTask(NewRunnableMethod(
+        automation_.get(),
+        &Automation::NavigateToURLAsync,
+        current_target_.window_id,
+        url,
+        &error));
+  } else {
+    RunSessionTask(NewRunnableMethod(
+        automation_.get(),
+        &Automation::NavigateToURL,
+        current_target_.window_id,
+        url,
+        &error));
+  }
   return error;
 }
 
 Error* Session::GoForward() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GoForward,
       current_target_.window_id,
       &error));
@@ skipping 784 matching lines @@
 }
 
 void Session::set_implicit_wait(int timeout_ms) {
   implicit_wait_ = timeout_ms;
 }
 
 int Session::implicit_wait() const {
   return implicit_wait_;
 }
 
-void Session::set_screenshot_on_error(bool error) {
-  screenshot_on_error_ = error;
-}
-
-bool Session::screenshot_on_error() const {
-  return screenshot_on_error_;
-}
-
-void Session::set_use_native_events(bool use_native_events) {
-  use_native_events_ = use_native_events;
-}
-
-bool Session::use_native_events() const {
-  return use_native_events_;
-}
-
 const gfx::Point& Session::get_mouse_position() const {
   return mouse_position_;
 }
 
+const Session::Options& Session::options() const {
+  return options_;
+}
+
 void Session::RunSessionTask(Task* task) {
   base::WaitableEvent done_event(false, false);
   thread_.message_loop_proxy()->PostTask(FROM_HERE, NewRunnableMethod(
       this,
       &Session::RunSessionTaskOnSessionThread,
       task,
       &done_event));
   done_event.Wait();
 }
 
@@ skipping 87 matching lines @@
 }
 
 void Session::SendKeysOnSessionThread(const string16& keys, Error** error) {
   std::vector<WebKeyEvent> key_events;
   std::string error_msg;
   if (!ConvertKeysToWebKeyEvents(keys, &key_events, &error_msg)) {
     *error = new Error(kUnknownError, error_msg);
     return;
   }
   for (size_t i = 0; i < key_events.size(); ++i) {
-    if (use_native_events_) {
+    if (options_.use_native_events) {
       // The automation provider will generate up/down events for us, we
       // only need to call it once as compared to the WebKeyEvent method.
       // Hence we filter events by their types, keeping only rawkeydown.
       if (key_events[i].type != automation::kRawKeyDownType)
         continue;
       automation_->SendNativeKeyEvent(
           current_target_.window_id,
           key_events[i].key_code,
           key_events[i].modifiers,
           error);
@@ skipping 263 matching lines @@
       path,
       &error));
   if (error)
     return error;
   if (!file_util::ReadFileToString(path, png))
     return new Error(kUnknownError, "Could not read screenshot file");
   return NULL;
 }
 
 }  // namespace webdriver