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

chrome/test/webdriver/session.h

 // 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.
 
 #ifndef CHROME_TEST_WEBDRIVER_SESSION_H_
 #define CHROME_TEST_WEBDRIVER_SESSION_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 35 matching lines @@
   int window_id;
   FramePath frame_path;
 };
 
 // Every connection made by WebDriver maps to a session object.
 // This object creates the chrome instance and keeps track of the
 // state necessary to control the chrome browser created.
 // A session manages its own lifetime.
 class Session {
  public:
+  struct Options {
+    Options();
+    ~Options();
+
+    // True if the session should simulate OS-level input. Currently only
+    // applies to keyboard input.
+    bool use_native_events;
+
+    // True if the session should not wait for page loads and navigate
+    // asynchronously.
+    bool load_async;
+  };
+
   // Adds this |Session| to the |SessionManager|. The session manages its own
   // lifetime. Do not call delete.
-  Session();
+  explicit Session(const Options& options);
+
   // Removes this |Session| from the |SessionManager|.
   ~Session();
 
   // Starts the session thread and a new browser, using the exe found at
   // |browser_exe| and duplicating the provided |user_data_dir|.
   // If |browser_exe| is empty, it will search in all the default locations.
   // It |user_data_dir| is empty, it will use a temporary dir.
   // Returns true on success. On failure, the session will delete
   // itself and return an error code.
   Error* Init(const FilePath& browser_exe,
               const FilePath& user_data_dir,
               const CommandLine& options);
 
+  // Should be called before executing a command. Performs necessary waits
+  // and frame switching.
+  Error* BeforeExecuteCommand();
+
   // Terminates this session and deletes itself.
   void Terminate();
 
   // Executes the given |script| in the context of the given frame.
   // The |script| should be in the form of a function body
   // (e.g. "return arguments[0]"), where |args| is the list of arguments to
   // pass to the function. The caller is responsible for the script result
   // |value|, which is set only if there is no error.
   Error* ExecuteScript(const FrameId& frame_id,
                        const std::string& script,
@@ skipping 195 matching lines @@
   const std::string& id() const;
 
   const FrameId& current_target() const;
 
   void set_async_script_timeout(int timeout_ms);
   int async_script_timeout() const;
 
   void set_implicit_wait(int timeout_ms);
   int implicit_wait() const;
 
-  void set_screenshot_on_error(bool error);
-  bool screenshot_on_error() const;
+  const gfx::Point& get_mouse_position() const;
 
-  void set_use_native_events(bool use_native_events);
-  bool use_native_events() const;
-
-  const gfx::Point& get_mouse_position() const;
+  const Options& options() const;
 
  private:
   void RunSessionTask(Task* task);
   void RunSessionTaskOnSessionThread(
       Task* task,
       base::WaitableEvent* done_event);
   void InitOnSessionThread(const FilePath& browser_exe,
                            const FilePath& user_data_dir,
                            const CommandLine& options,
                            Error** error);
@@ skipping 34 matching lines @@
 
   scoped_ptr<Automation> automation_;
   base::Thread thread_;
 
   // Timeout (in ms) for asynchronous script execution.
   int async_script_timeout_;
 
   // Time (in ms) of how long to wait while searching for a single element.
   int implicit_wait_;
 
-  // Since screenshots can be very large when in base64 PNG format; the
-  // client is allowed to dyamically enable/disable screenshots on error
-  // during the lifetime of the session.
-  bool screenshot_on_error_;
-
-  // True if the session should simulate OS-level input. Currently only applies
-  // to keyboard input.
-  bool use_native_events_;
-
   // Vector of the |WebElementId|s for each frame of the current target frame
   // path. The first refers to the first frame element in the root document.
   // If the target frame is window.top, this will be empty.
   std::vector<WebElementId> frame_elements_;
 
   // Last mouse position. Advanced APIs need this value.
   gfx::Point mouse_position_;
 
   // Chrome does not have an individual method for setting the prompt text
   // of an alert. Instead, when the WebDriver client wants to set the text,
   // we store it here and pass the text when the alert is accepted or
   // dismissed. This text should only be used if |has_alert_prompt_text_|
   // is true, so that the default prompt text is not overridden.
   std::string alert_prompt_text_;
   bool has_alert_prompt_text_;
 
+  Options options_;
+
   DISALLOW_COPY_AND_ASSIGN(Session);
 };
 
 }  // namespace webdriver
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(webdriver::Session);
 
 #endif  // CHROME_TEST_WEBDRIVER_SESSION_H_