Refactor chromedriver's script execution to reduce amount of custom Value parsing.

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>
 
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/threading/thread.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/test/webdriver/automation.h"
 #include "chrome/test/webdriver/frame_path.h"
 #include "chrome/test/webdriver/web_element_id.h"
-#include "ui/gfx/point.h"
+#include "chrome/test/webdriver/webdriver_basic_types.h"
 
 class CommandLine;
 class FilePath;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 class Value;
 class WaitableEvent;
 }
 
-namespace gfx {
-class Rect;
-class Size;
-}
-
 namespace webdriver {
 
 class Error;
+class ValueParser;
 
 // A window ID and frame path combination that uniquely identifies a specific
 // frame within a session.
 struct FrameId {
   FrameId(int window_id, const FramePath& frame_path);
   FrameId& operator=(const FrameId& other);
   int window_id;
   FramePath frame_path;
 };
 
@@ skipping 46 matching lines @@
   Error* ExecuteScript(const FrameId& frame_id,
                        const std::string& script,
                        const base::ListValue* const args,
                        base::Value** value);
 
   // Same as above, but uses the currently targeted window and frame.
   Error* ExecuteScript(const std::string& script,
                        const base::ListValue* const args,
                        base::Value** value);
 
+  // Executes the given script in the context of the given frame and parses
+  // the value with the given parser. The script should be in the form of an
+  // anonymous function. |script_name| is only used when creating error
+  // messages. This function takes ownership of |args| and |parser|.
+  Error* ExecuteScriptAndParse(const FrameId& frame_id,
+                               const std::string& anonymous_func_script,
+                               const std::string& script_name,
+                               const base::ListValue* args,
+                               const ValueParser* parser);
+
   // Executes 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* ExecuteAsyncScript(const FrameId& frame_id,
                             const std::string& script,
                             const base::ListValue* const args,
                             base::Value** value);
 
   // Send the given keys to the given element dictionary. This function takes
   // ownership of |element|.
   Error* SendKeys(const WebElementId& element, const string16& keys);
 
   // Sets the file paths to the file upload control under the given location.
-  Error* DragAndDropFilePaths(const gfx::Point& location,
+  Error* DragAndDropFilePaths(const Point& location,
                               const std::vector<FilePath::StringType>& paths);
 
   // Clicks the mouse at the given location using the given button.
-  Error* MouseMoveAndClick(const gfx::Point& location,
+  Error* MouseMoveAndClick(const Point& location,
                            automation::MouseButton button);
-  Error* MouseMove(const gfx::Point& location);
-  Error* MouseDrag(const gfx::Point& start, const gfx::Point& end);
+  Error* MouseMove(const Point& location);
+  Error* MouseDrag(const Point& start, const Point& end);
   Error* MouseClick(automation::MouseButton button);
   Error* MouseButtonDown();
   Error* MouseButtonUp();
   Error* MouseDoubleClick();
 
   Error* NavigateToURL(const std::string& url);
   Error* GoForward();
   Error* GoBack();
   Error* Reload();
   Error* GetURL(std::string* url);
@@ skipping 68 matching lines @@
   Error* FindElements(const FrameId& frame_id,
                       const WebElementId& root_element,
                       const std::string& locator,
                       const std::string& query,
                       std::vector<WebElementId>* elements);
 
   // Scroll the element into view and get its location relative to
   // the client's viewport.
   Error* GetElementLocationInView(
       const WebElementId& element,
-      gfx::Point* location);
+      Point* location);
 
   // Scroll the element's region into view and get its location relative to
   // the client's viewport. If |center| is true, the element will be centered
   // if it is too big to fit in view. If |verify_clickable_at_middle| is true,
   // an error will be returned if the element is not clickable in the middle
   // of the given region.
   Error* GetElementRegionInView(
       const WebElementId& element,
-      const gfx::Rect& region,
+      const Rect& region,
       bool center,
       bool verify_clickable_at_middle,
-      gfx::Point* location);
+      Point* location);
 
   // Gets the size of the element from the given window and frame, even if
   // its display is none.
   Error* GetElementSize(const FrameId& frame_id,
                         const WebElementId& element,
-                        gfx::Size* size);
+                        Size* size);
 
   // Gets the size of the element's first client rect. If the element has
   // no client rects, this will return an error.
   Error* GetElementFirstClientRect(const FrameId& frame_id,
                                    const WebElementId& element,
-                                   gfx::Rect* rect);
+                                   Rect* rect);
 
   // Gets the element's effective style for the given property.
   Error* GetElementEffectiveStyle(
       const FrameId& frame_id,
       const WebElementId& element,
       const std::string& prop,
       std::string* value);
 
   // Gets the top and left element border widths for the given frame.
   Error* GetElementBorder(const FrameId& frame_id,
@@ skipping 30 matching lines @@
 
   // Gets the tag name of the given element.
   Error* GetElementTagName(const FrameId& frame_id,
                            const WebElementId& element,
                            std::string* tag_name);
 
   // Gets the clickable location of the given element. It will be the center
   // location of the element. If the element is not clickable, or if the
   // location cannot be determined, an error will be returned.
   Error* GetClickableLocation(const WebElementId& element,
-                              gfx::Point* location);
+                              Point* location);
 
   // Gets the attribute of the given element. If there are no errors, the
   // function sets |value| and the caller takes ownership.
   Error* GetAttribute(const WebElementId& element, const std::string& key,
                       base::Value** value);
 
   // Waits for all tabs to stop loading. Returns true on success.
   Error* WaitForAllTabsToStopLoading();
 
   // Install packed extension at |path|.
   Error* InstallExtension(const FilePath& path);
 
   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;
 
-  const gfx::Point& get_mouse_position() const;
+  const Point& get_mouse_position() const;
 
   const Options& options() const;
 
   // Gets the browser connection state.
   Error* GetBrowserConnectionState(bool* online);
 
   // Gets the status of the application cache.
   Error* GetAppCacheStatus(int* status);
 
  private:
   void RunSessionTask(Task* task);
   void RunSessionTaskOnSessionThread(
       Task* task,
       base::WaitableEvent* done_event);
   void InitOnSessionThread(const Automation::BrowserOptions& options,
                            Error** error);
   void TerminateOnSessionThread();
 
   // Executes the given |script| in the context of the given frame.
   // Waits for script to finish and parses the response.
   // The caller is responsible for the script result |value|.
-  Error* ExecuteScriptAndParseResponse(const FrameId& frame_id,
-                                       const std::string& script,
-                                       base::Value** value);
+  Error* ExecuteScriptAndParseValue(const FrameId& frame_id,
+                                    const std::string& script,
+                                    base::Value** value);
 
   void SendKeysOnSessionThread(const string16& keys, Error** error);
   Error* SwitchToFrameWithJavaScriptLocatedFrame(
       const std::string& script,
       base::ListValue* args);
   Error* FindElementsHelper(const FrameId& frame_id,
                             const WebElementId& root_element,
                             const std::string& locator,
                             const std::string& query,
                             bool find_one,
                             std::vector<WebElementId>* elements);
+  Error* ExecuteFindElementScriptAndParse(const FrameId& frame_id,
+                                          const WebElementId& root_element,
+                                          const std::string& locator,
+                                          const std::string& query,
+                                          bool find_one,
+                                          std::vector<WebElementId>* elements);
   // Returns an error if the element is not clickable.
   Error* VerifyElementIsClickable(
       const FrameId& frame_id,
       const WebElementId& element,
-      const gfx::Point& location);
+      const Point& location);
   Error* GetElementRegionInViewHelper(
       const FrameId& frame_id,
       const WebElementId& element,
-      const gfx::Rect& region,
+      const Rect& region,
       bool center,
       bool verify_clickable_at_middle,
-      gfx::Point* location);
+      Point* location);
 
   const std::string id_;
   FrameId current_target_;
 
   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_;
 
   // 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_;
+  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_