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

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 14 matching lines @@
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/automation_json_requests.h"
+#include "chrome/test/automation/value_conversion_util.h"
+#include "chrome/test/webdriver/session_manager.h"
 #include "chrome/test/webdriver/webdriver_error.h"
-#include "chrome/test/webdriver/session_manager.h"
-#include "chrome/test/webdriver/utility_functions.h"
 #include "chrome/test/webdriver/webdriver_key_converter.h"
+#include "chrome/test/webdriver/webdriver_util.h"
 #include "third_party/webdriver/atoms.h"
-#include "ui/gfx/point.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/size.h"
 
 namespace webdriver {
 
 FrameId::FrameId(int window_id, const FramePath& frame_path)
     : window_id(window_id),
       frame_path(frame_path) {
 }
 
 FrameId& FrameId::operator=(const FrameId& other) {
   window_id = other.window_id;
@@ skipping 55 matching lines @@
                           &args_as_json);
 
   // Every injected script is fed through the executeScript atom. This atom
   // will catch any errors that are thrown and convert them to the
   // appropriate JSON structure.
   std::string jscript = base::StringPrintf(
       "window.domAutomationController.send((%s).apply(null,"
       "[function(){%s\n},%s,true]));",
       atoms::EXECUTE_SCRIPT, script.c_str(), args_as_json.c_str());
 
-  return ExecuteScriptAndParseResponse(frame_id, jscript, value);
+  return ExecuteScriptAndParseValue(frame_id, jscript, value);
 }
 
 Error* Session::ExecuteScript(const std::string& script,
                               const ListValue* const args,
                               Value** value) {
   return ExecuteScript(current_target_, script, args, value);
 }
 
+Error* Session::ExecuteScriptAndParse(const FrameId& frame_id,
+                                      const std::string& anonymous_func_script,
+                                      const std::string& script_name,
+                                      const ListValue* args,
+                                      const ValueParser* parser) {
+  scoped_ptr<const ListValue> scoped_args(args);
+  scoped_ptr<const ValueParser> scoped_parser(parser);
+  std::string called_script = base::StringPrintf(
+      "return (%s).apply(null, arguments);", anonymous_func_script.c_str());
+  Value* unscoped_value = NULL;
+  Error* error = ExecuteScript(frame_id, called_script, args, &unscoped_value);
+  if (error) {
+    error->AddDetails(script_name + " execution failed");
+    return error;
+  }
+
+  scoped_ptr<Value> value(unscoped_value);
+  std::string error_msg;
+  if (!parser->Parse(value.get())) {
+    error_msg = base::StringPrintf("%s returned invalid value: %s",
+        script_name.c_str(), JsonStringify(value.get()).c_str());
+    return new Error(kUnknownError, error_msg);
+  }
+  return NULL;
+}
+
 Error* Session::ExecuteAsyncScript(const FrameId& frame_id,
                                    const std::string& script,
                                    const ListValue* const args,
                                    Value** value) {
   std::string args_as_json;
   base::JSONWriter::Write(static_cast<const Value* const>(args),
                           /*pretty_print=*/false,
                           &args_as_json);
 
   int timeout_ms = async_script_timeout();
 
   // Every injected script is fed through the executeScript atom. This atom
   // will catch any errors that are thrown and convert them to the
   // appropriate JSON structure.
   std::string jscript = base::StringPrintf(
       "(%s).apply(null, [function(){%s},%s,%d,%s,true]);",
       atoms::EXECUTE_ASYNC_SCRIPT,
       script.c_str(),
       args_as_json.c_str(),
       timeout_ms,
       "function(result) {window.domAutomationController.send(result);}");
 
-  return ExecuteScriptAndParseResponse(frame_id, jscript, value);
+  return ExecuteScriptAndParseValue(frame_id, jscript, value);
 }
 
 Error* Session::SendKeys(const WebElementId& element, const string16& keys) {
   bool is_displayed = false;
   Error* error = IsElementDisplayed(
       current_target_, element, true /* ignore_opacity */, &is_displayed);
   if (error)
     return error;
   if (!is_displayed)
     return new Error(kElementNotVisible);
 
   bool is_enabled = false;
   error = IsElementEnabled(current_target_, element, &is_enabled);
   if (error)
     return error;
   if (!is_enabled)
     return new Error(kInvalidElementState);
 
-  ListValue args;
-  args.Append(element.ToValue());
   // Focus the target element in order to send keys to it.
   // First, the currently active element is blurred, if it is different from
   // the target element. We do not want to blur an element unnecessarily,
   // because this may cause us to lose the current cursor position in the
   // element.
   // Secondly, we focus the target element.
   // Thirdly, if the target element is newly focused and is a text input, we
   // set the cursor position at the end.
   // Fourthly, we check if the new active element is the target element. If not,
   // we throw an error.
   // Additional notes:
   //   - |document.activeElement| is the currently focused element, or body if
   //     no element is focused
   //   - Even if |document.hasFocus()| returns true and the active element is
   //     the body, sometimes we still need to focus the body element for send
   //     keys to work. Not sure why
   //   - You cannot focus a descendant of a content editable node
   // TODO(jleyba): Update this to use the correct atom.
   const char* kFocusScript =
-      "var elem = arguments[0];"
-      "var doc = elem.ownerDocument || elem;"
-      "var prevActiveElem = doc.activeElement;"
-      "if (elem != prevActiveElem && prevActiveElem)"
-      "  prevActiveElem.blur();"
-      "elem.focus();"
-      "if (elem != prevActiveElem && elem.value && elem.value.length &&"
-      "    elem.setSelectionRange) {"
-      "  elem.setSelectionRange(elem.value.length, elem.value.length);"
-      "}"
-      "if (elem != doc.activeElement)"
-      "  throw new Error('Failed to send keys because cannot focus element.');";
-  Value* unscoped_result = NULL;
-  error = ExecuteScript(kFocusScript, &args, &unscoped_result);
+      "function(elem) {"
+      "  var doc = elem.ownerDocument || elem;"
+      "  var prevActiveElem = doc.activeElement;"
+      "  if (elem != prevActiveElem && prevActiveElem)"
+      "    prevActiveElem.blur();"
+      "  elem.focus();"
+      "  if (elem != prevActiveElem && elem.value && elem.value.length &&"
+      "      elem.setSelectionRange) {"
+      "    elem.setSelectionRange(elem.value.length, elem.value.length);"
+      "  }"
+      "  if (elem != doc.activeElement)"
+      "    throw new Error('Failed to send keys because cannot focus element');"
+      "}";
+  error = ExecuteScriptAndParse(current_target_,
+                                kFocusScript,
+                                "focusElement",
+                                CreateListValueFrom(element),
+                                CreateDirectValueParser(kSkipParsing));
   if (error)
     return error;
 
-  error = NULL;
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::SendKeysOnSessionThread,
       keys,
       &error));
   return error;
 }
 
 Error* Session::DragAndDropFilePaths(
-    const gfx::Point& location,
+    const Point& location,
     const std::vector<FilePath::StringType>& paths) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::DragAndDropFilePaths,
       current_target_.window_id,
       location,
       paths,
       &error));
   return error;
@@ skipping 34 matching lines @@
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::Reload,
       current_target_.window_id,
       &error));
   return error;
 }
 
 Error* Session::GetURL(std::string* url) {
-  ListValue no_args;
-  Value* unscoped_value = NULL;
-  Error* error = ExecuteScript(current_target_,
-                               "return document.URL;",
-                               &no_args,
-                               &unscoped_value);
-  scoped_ptr<Value> value(unscoped_value);
-  if (error)
-    return error;
-  if (!value->GetAsString(url))
-    return new Error(kUnknownError, "GetURL Script returned non-string: " +
-                         JsonStringify(value.get()));
-  return NULL;
+  return ExecuteScriptAndParse(current_target_,
+                               "function() { return document.URL }",
+                               "getUrl",
+                               new ListValue(),
+                               CreateDirectValueParser(url));
 }
 
 Error* Session::GetTitle(std::string* tab_title) {
-  std::string script =
-      "if (document.title)"
-      "  return document.title;"
-      "else"
-      "  return document.URL;";
-
-  ListValue no_args;
-  Value* unscoped_value = NULL;
-  Error* error = ExecuteScript(current_target_,
-                               script,
-                               &no_args,
-                               &unscoped_value);
-  scoped_ptr<Value> value(unscoped_value);
-  if (error)
-    return error;
-  if (!value->GetAsString(tab_title))
-    return new Error(kUnknownError, "GetTitle script returned non-string: " +
-                         JsonStringify(value.get()));
-  return NULL;
+  const char* kGetTitleScript =
+      "function() {"
+      "  if (document.title)"
+      "    return document.title;"
+      "  else"
+      "    return document.URL;"
+      "}";
+  return ExecuteScriptAndParse(current_target_,
+                               kGetTitleScript,
+                               "getTitle",
+                               new ListValue(),
+                               CreateDirectValueParser(tab_title));
 }
 
-Error* Session::MouseMoveAndClick(const gfx::Point& location,
+Error* Session::MouseMoveAndClick(const Point& location,
                                   automation::MouseButton button) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseClick,
       current_target_.window_id,
       location,
       button,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
-Error* Session::MouseMove(const gfx::Point& location) {
+Error* Session::MouseMove(const Point& location) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseMove,
       current_target_.window_id,
       location,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
-Error* Session::MouseDrag(const gfx::Point& start,
-                          const gfx::Point& end) {
+Error* Session::MouseDrag(const Point& start,
+                          const Point& end) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseDrag,
       current_target_.window_id,
       start,
       end,
       &error));
   if (!error)
     mouse_position_ = end;
@@ skipping 100 matching lines @@
       switch_to_id = name_no;
   }
 
   if (!switch_to_id) {
     std::vector<int> window_ids;
     Error* error = GetWindowIds(&window_ids);
     if (error)
       return error;
     // See if any of the window names match |name|.
     for (size_t i = 0; i < window_ids.size(); ++i) {
-      ListValue empty_list;
-      Value* unscoped_name_value = NULL;
       std::string window_name;
-      Error* error = ExecuteScript(FrameId(window_ids[i], FramePath()),
-                                   "return window.name;",
-                                   &empty_list,
-                                   &unscoped_name_value);
+      Error* error = ExecuteScriptAndParse(
+          FrameId(window_ids[i], FramePath()),
+          "function() { return window.name; }",
+          "getWindowName",
+          new ListValue(),
+          CreateDirectValueParser(&window_name));
       if (error)
         return error;
-      scoped_ptr<Value> name_value(unscoped_name_value);
-      if (name_value->GetAsString(&window_name) &&
-          name == window_name) {
+      if (name == window_name) {
         switch_to_id = window_ids[i];
         break;
       }
     }
   }
 
   if (!switch_to_id)
     return new Error(kNoSuchWindow);
   frame_elements_.clear();
   current_target_ = FrameId(switch_to_id, FramePath());
   return NULL;
 }
 
 Error* Session::SwitchToFrameWithNameOrId(const std::string& name_or_id) {
   std::string script =
-      "var arg = arguments[0];"
-      "var xpath = '(/html/body//iframe|/html/frameset/frame)';"
-      "var sub = function(s) { return s.replace(/\\$/g, arg); };"
-      "xpath += sub('[@name=\"$\" or @id=\"$\"]');"
-      "var frame = document.evaluate(xpath, document, null, "
-      "    XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;"
-      "if (!frame) { return null; }"
-      "xpath = frame.tagName == 'IFRAME' ? '/html/body//iframe'"
-      "                                  : '/html/frameset/frame';"
-      "frame_xpath = xpath + "
-      "              sub('[@' + (frame.id == arg ? 'id' : 'name') + '=\"$\"]');"
-      "return [frame, frame_xpath];";
-  ListValue args;
-  args.Append(new StringValue(name_or_id));
-  return SwitchToFrameWithJavaScriptLocatedFrame(script, &args);
+      "function(arg) {"
+      "  var xpath = '(/html/body//iframe|/html/frameset/frame)';"
+      "  var sub = function(s) { return s.replace(/\\$/g, arg); };"
+      "  xpath += sub('[@name=\"$\" or @id=\"$\"]');"
+      "  var frame = document.evaluate(xpath, document, null, "
+      "      XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;"
+      "  if (!frame) { return null; }"
+      "  xpath = frame.tagName == 'IFRAME' ? '/html/body//iframe'"
+      "                                    : '/html/frameset/frame';"
+      "  frame_xpath = xpath + "
+      "      sub('[@' + (frame.id == arg ? 'id' : 'name') + '=\"$\"]');"
+      "  return [frame, frame_xpath];"
+      "}";
+  return SwitchToFrameWithJavaScriptLocatedFrame(
+      script, CreateListValueFrom(name_or_id));
 }
 
 Error* Session::SwitchToFrameWithIndex(int index) {
   // We cannot simply index into window.frames because we need to know the
   // tagName of the frameElement. If child frame N is from another domain, then
   // the following will run afoul of the same origin policy:
   //   window.frames[N].frameElement;
   // Instead of indexing window.frames, we use a an XPath expression to index
   // into the list of all IFRAME and FRAME elements on the page - if we find
   // something, then that XPath expression can be used as the new frame's XPath.
   std::string script =
-      "var index = '[' + (arguments[0] + 1) + ']';"
-      "var xpath = '(/html/body//iframe|/html/frameset/frame)' + "
-      "            index;"
-      "console.info('searching for frame by xpath: ' + xpath);"
-      "var frame = document.evaluate(xpath, document, null, "
-      "XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;"
-      "console.info(frame == null ? 'found nothing' : frame);"
-      "if (!frame) { return null; }"
-      "frame_xpath = ((frame.tagName == 'IFRAME' ? "
-      "    '(/html/body//iframe)' : '/html/frameset/frame') + index);"
-      "return [frame, frame_xpath];";
-  ListValue args;
-  args.Append(Value::CreateIntegerValue(index));
-  return SwitchToFrameWithJavaScriptLocatedFrame(script, &args);
+      "function(index) {"
+      "  var xpathIndex = '[' + (index + 1) + ']';"
+      "  var xpath = '(/html/body//iframe|/html/frameset/frame)' + "
+      "              xpathIndex;"
+      "  var frame = document.evaluate(xpath, document, null, "
+      "  XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;"
+      "  if (!frame) { return null; }"
+      "  frame_xpath = ((frame.tagName == 'IFRAME' ? "
+      "      '(/html/body//iframe)' : '/html/frameset/frame') + xpathIndex);"
+      "  return [frame, frame_xpath];"
+      "}";
+  return SwitchToFrameWithJavaScriptLocatedFrame(
+      script, CreateListValueFrom(index));
 }
 
 Error* Session::SwitchToFrameWithElement(const WebElementId& element) {
   // TODO(jleyba): Extract this, and the other frame switch methods to an atom.
   std::string script =
-      "var element = arguments[0];"
-      "console.info('Attempting to switch to ' + element);"
-      "if (element.nodeType != 1 || !/^i?frame$/i.test(element.tagName)) {"
-      "  console.info('Element is not a frame: ' + element + "
-      "' {nodeType:' + element.nodeType + ',tagName:' + element.tagName + '}');"
+      "function(elem) {"
+      "  if (elem.nodeType != 1 || !/^i?frame$/i.test(elem.tagName)) {"
+      "    console.error('Element is not a frame');"
+      "    return null;"
+      "  }"
+      "  for (var i = 0; i < window.frames.length; i++) {"
+      "    if (elem.contentWindow == window.frames[i]) {"
+      "      return [elem, '(//iframe|//frame)[' + (i + 1) + ']'];"
+      "    }"
+      "  }"
+      "  console.info('Frame is not connected to this DOM tree');"
       "  return null;"
-      "}"
-      "for (var i = 0; i < window.frames.length; i++) {"
-      "  if (element.contentWindow == window.frames[i]) {"
-      "    return [element, '(//iframe|//frame)[' + (i + 1) + ']'];"
-      "  }"
-      "}"
-      "console.info('Frame is not connected to this DOM tree');"
-      "return null;";
-
-  ListValue args;
-  args.Append(element.ToValue());
-  return SwitchToFrameWithJavaScriptLocatedFrame(script, &args);
+      "}";
+  return SwitchToFrameWithJavaScriptLocatedFrame(
+      script, CreateListValueFrom(element));
 }
 
 void Session::SwitchToTopFrame() {
   frame_elements_.clear();
   current_target_.frame_path = FramePath();
 }
 
 Error* Session::SwitchToTopFrameIfCurrentFrameInvalid() {
   std::vector<std::string> components;
   current_target_.frame_path.GetComponents(&components);
   if (frame_elements_.size() != components.size()) {
     return new Error(kUnknownError,
                      "Frame element vector out of sync with frame path");
   }
   FramePath frame_path;
   // Start from the root path and check that each frame element that makes
   // up the current frame target is valid by executing an empty script.
   // This code should not execute script in any frame before making sure the
   // frame element is valid, otherwise the automation hangs until a timeout.
   for (size_t i = 0; i < frame_elements_.size(); ++i) {
     FrameId frame_id(current_target_.window_id, frame_path);
-    ListValue args;
-    args.Append(frame_elements_[i].ToValue());
-    Value* unscoped_value = NULL;
-    scoped_ptr<Error> error(ExecuteScript(
-        frame_id, "", &args, &unscoped_value));
-
-    scoped_ptr<Value> value(unscoped_value);
+    scoped_ptr<Error> error(ExecuteScriptAndParse(
+        frame_id,
+        "function(){ }",
+        "emptyScript",
+        CreateListValueFrom(frame_elements_[i]),
+        CreateDirectValueParser(kSkipParsing)));
     if (error.get() && error->code() == kStaleElementReference) {
       SwitchToTopFrame();
     } else if (error.get()) {
       return error.release();
     }
     frame_path = frame_path.Append(components[i]);
   }
   return NULL;
 }
 
@@ skipping 112 matching lines @@
                              const WebElementId& root_element,
                              const std::string& locator,
                              const std::string& query,
                              std::vector<WebElementId>* elements) {
   return FindElementsHelper(
       frame_id, root_element, locator, query, false, elements);
 }
 
 Error* Session::GetElementLocationInView(
     const WebElementId& element,
-    gfx::Point* location) {
-  gfx::Size size;
+    Point* location) {
+  Size size;
   Error* error = GetElementSize(current_target_, element, &size);
   if (error)
     return error;
   return GetElementRegionInView(
-      element, gfx::Rect(gfx::Point(0, 0), size),
-      false /* center */, location);
+      element, Rect(Point(0, 0), size), false /* center */, location);
 }
 
 Error* Session::GetElementRegionInView(
     const WebElementId& element,
-    const gfx::Rect& region,
+    const Rect& region,
     bool center,
-    gfx::Point* location) {
+    Point* location) {
   CHECK(element.is_valid());
 
-  gfx::Point region_offset = region.origin();
-  gfx::Size region_size = region.size();
+  Point region_offset = region.origin();
+  Size region_size = region.size();
   Error* error = GetElementRegionInViewHelper(
       current_target_, element, region, center, &region_offset);
   if (error)
     return error;
 
   for (FramePath frame_path = current_target_.frame_path;
        frame_path.IsSubframe();
        frame_path = frame_path.Parent()) {
     // Find the frame element for the current frame path.
     FrameId frame_id(current_target_.window_id, frame_path.Parent());
@@ skipping 11 matching lines @@
     }
     // Modify |region_offset| by the frame's border.
     int border_left, border_top;
     error = GetElementBorder(
         frame_id, frame_element, &border_left, &border_top);
     if (error)
       return error;
     region_offset.Offset(border_left, border_top);
 
     error = GetElementRegionInViewHelper(
-        frame_id, frame_element, gfx::Rect(region_offset, region_size),
+        frame_id, frame_element, Rect(region_offset, region_size),
         center, &region_offset);
     if (error)
       return error;
   }
   *location = region_offset;
   return NULL;
 }
 
 Error* Session::GetElementSize(const FrameId& frame_id,
                                const WebElementId& element,
-                               gfx::Size* size) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_SIZE);
-  ListValue args;
-  args.Append(element.ToValue());
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error)
-    return error;
-  if (!result->IsType(Value::TYPE_DICTIONARY)) {
-    return new Error(kUnknownError, "GetSize atom returned non-dict type: " +
-                         JsonStringify(result.get()));
-  }
-  DictionaryValue* dict = static_cast<DictionaryValue*>(result.get());
-  int width, height;
-  if (!dict->GetInteger("width", &width) ||
-      !dict->GetInteger("height", &height)) {
-    return new Error(kUnknownError, "GetSize atom returned invalid dict: " +
-                         JsonStringify(dict));
-  }
-  *size = gfx::Size(width, height);
-  return NULL;
+                               Size* size) {
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::GET_SIZE,
+                               "getSize",
+                               CreateListValueFrom(element),
+                               CreateDirectValueParser(size));
 }
 
 Error* Session::GetElementFirstClientRect(const FrameId& frame_id,
                                           const WebElementId& element,
-                                          gfx::Rect* rect) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_FIRST_CLIENT_RECT);
-  ListValue args;
-  args.Append(element.ToValue());
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error)
-    return error;
-  if (!result->IsType(Value::TYPE_DICTIONARY)) {
-    return new Error(
-        kUnknownError,
-        "GetFirstClientRect atom returned non-dict type: " +
-            JsonStringify(result.get()));
-  }
-  DictionaryValue* dict = static_cast<DictionaryValue*>(result.get());
-  // TODO(kkania): Convert the atom to return integers.
-  double left, top, width, height;
-  if (!dict->GetDouble("left", &left) ||
-      !dict->GetDouble("top", &top) ||
-      !dict->GetDouble("width", &width) ||
-      !dict->GetDouble("height", &height)) {
-    return new Error(
-        kUnknownError,
-        "GetFirstClientRect atom returned invalid dict: " +
-            JsonStringify(dict));
-  }
-  *rect = gfx::Rect(static_cast<int>(left), static_cast<int>(top),
-                    static_cast<int>(width), static_cast<int>(height));
-  return NULL;
+                                          Rect* rect) {
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::GET_FIRST_CLIENT_RECT,
+                               "getFirstClientRect",
+                               CreateListValueFrom(element),
+                               CreateDirectValueParser(rect));
 }
 
 Error* Session::GetElementEffectiveStyle(
     const FrameId& frame_id,
     const WebElementId& element,
     const std::string& prop,
     std::string* value) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_EFFECTIVE_STYLE);
-  ListValue args;
-  args.Append(element.ToValue());
-  args.Append(Value::CreateStringValue(prop));
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(
-      frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error) {
-    error->AddDetails(base::StringPrintf(
-        "GetEffectiveStyle atom failed for property (%s)", prop.c_str()));
-    return error;
-  }
-
-  if (!result->GetAsString(value)) {
-    std::string context = base::StringPrintf(
-        "GetEffectiveStyle atom returned non-string for property (%s): %s",
-        prop.c_str(), JsonStringify(result.get()).c_str());
-    return new Error(kUnknownError, context);
-  }
-  return NULL;
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::GET_EFFECTIVE_STYLE,
+                               "getEffectiveStyle",
+                               CreateListValueFrom(element, prop),
+                               CreateDirectValueParser(value));
 }
 
 Error* Session::GetElementBorder(const FrameId& frame_id,
                                  const WebElementId& element,
                                  int* border_left,
                                  int* border_top) {
   std::string border_left_str, border_top_str;
   Error* error = GetElementEffectiveStyle(
       frame_id, element, "border-left-width", &border_left_str);
   if (error)
     return error;
   error = GetElementEffectiveStyle(
       frame_id, element, "border-top-width", &border_top_str);
   if (error)
     return error;
 
   base::StringToInt(border_left_str, border_left);
   base::StringToInt(border_top_str, border_top);
   return NULL;
 }
 
 Error* Session::IsElementDisplayed(const FrameId& frame_id,
                                    const WebElementId& element,
                                    bool ignore_opacity,
                                    bool* is_displayed) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::IS_DISPLAYED);
-  ListValue args;
-  args.Append(element.ToValue());
-  args.Append(Value::CreateBooleanValue(ignore_opacity));
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error)
-    return error;
-  if (!result->GetAsBoolean(is_displayed))
-    return new Error(kUnknownError, "IsDisplayed atom returned non-boolean: " +
-                         JsonStringify(result.get()));
-  return NULL;
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::IS_DISPLAYED,
+                               "isDisplayed",
+                               CreateListValueFrom(element, ignore_opacity),
+                               CreateDirectValueParser(is_displayed));
 }
 
 Error* Session::IsElementEnabled(const FrameId& frame_id,
                                  const WebElementId& element,
                                  bool* is_enabled) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::IS_ENABLED);
-  ListValue args;
-  args.Append(element.ToValue());
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error)
-    return error;
-  if (!result->GetAsBoolean(is_enabled))
-    return new Error(kUnknownError, "IsEnabled atom returned non-boolean: " +
-                         JsonStringify(result.get()));
-  return NULL;
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::IS_ENABLED,
+                               "isEnabled",
+                               CreateListValueFrom(element),
+                               CreateDirectValueParser(is_enabled));
 }
 
 Error* Session::SelectOptionElement(const FrameId& frame_id,
                                     const WebElementId& element) {
-  ListValue args;
-  args.Append(element.ToValue());
-  args.Append(Value::CreateBooleanValue(true));
-
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::SET_SELECTED);
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  return error;
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::SET_SELECTED,
+                               "setSelected",
+                               CreateListValueFrom(element, true),
+                               CreateDirectValueParser(kSkipParsing));
 }
 
 Error* Session::GetElementTagName(const FrameId& frame_id,
                                   const WebElementId& element,
                                   std::string* tag_name) {
-  ListValue args;
-  args.Append(element.ToValue());
-
-  std::string script = "return arguments[0].tagName.toLocaleLowerCase();";
-
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(frame_id, script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (error)
-    return error;
-  if (!result->GetAsString(tag_name))
-    return new Error(kUnknownError, "TagName script returned non-string: " +
-                         JsonStringify(result.get()));
-  return NULL;
+  return ExecuteScriptAndParse(
+      frame_id,
+      "function(elem) { return elem.tagName.toLowerCase() }",
+      "getElementTagName",
+      CreateListValueFrom(element),
+      CreateDirectValueParser(tag_name));
 }
 
 Error* Session::GetClickableLocation(const WebElementId& element,
-                                     gfx::Point* location) {
+                                     Point* location) {
   bool is_displayed = false;
   Error* error = IsElementDisplayed(
       current_target_, element, true /* ignore_opacity */, &is_displayed);
   if (error)
     return error;
   if (!is_displayed)
     return new Error(kElementNotVisible, "Element must be displayed to click");
 
-  gfx::Rect rect;
+  Rect rect;
   error = GetElementFirstClientRect(current_target_, element, &rect);
   if (error)
     return error;
 
-  error = GetElementRegionInView(element, rect, true /* center */, location);
+  error = GetElementRegionInView(
+      element, rect, true /* center */, location);
   if (error)
     return error;
   location->Offset(rect.width() / 2, rect.height() / 2);
   return NULL;
 }
 
 Error* Session::GetAttribute(const WebElementId& element,
-                             const std::string& key, Value** value) {
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_ATTRIBUTE);
-
-  ListValue args;
-  args.Append(element.ToValue());
-  args.Append(Value::CreateStringValue(key));
-
-  Error* error = ExecuteScript(script, &args, value);
-  if (error) {
-    return error;
-  }
-
-  return NULL;
+                             const std::string& key,
+                             Value** value) {
+  return ExecuteScriptAndParse(current_target_,
+                               atoms::GET_ATTRIBUTE,
+                               "getAttribute",
+                               CreateListValueFrom(element, key),
+                               CreateDirectValueParser(value));
 }
 
 Error* Session::WaitForAllTabsToStopLoading() {
   if (!automation_.get())
     return NULL;
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::WaitForAllTabsToStopLoading,
       &error));
@@ skipping 33 matching lines @@
 }
 
 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 {
+const Point& Session::get_mouse_position() const {
   return mouse_position_;
 }
 
 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));
@@ skipping 32 matching lines @@
   }
   current_target_ = FrameId(tab_ids[0], FramePath());
 }
 
 void Session::TerminateOnSessionThread() {
   if (automation_.get())
     automation_->Terminate();
   automation_.reset();
 }
 
-Error* Session::ExecuteScriptAndParseResponse(const FrameId& frame_id,
-                                              const std::string& script,
-                                              Value** script_result) {
+Error* Session::ExecuteScriptAndParseValue(const FrameId& frame_id,
+                                           const std::string& script,
+                                           Value** script_result) {
   std::string response_json;
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::ExecuteScript,
       frame_id.window_id,
       frame_id.frame_path,
       script,
       &response_json,
       &error));
@@ skipping 68 matching lines @@
           key_events[i].modified_text.c_str(),
           key_events[i].modifiers);
       (*error)->AddDetails(details);
       return;
     }
   }
 }
 
 Error* Session::SwitchToFrameWithJavaScriptLocatedFrame(
     const std::string& script, ListValue* args) {
-  Value* unscoped_result = NULL;
-  Error* error = ExecuteScript(script, args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
+  class SwitchFrameValueParser : public ValueParser {
+   public:
+    SwitchFrameValueParser(
+        bool* found_frame, WebElementId* frame, std::string* xpath)
+        : found_frame_(found_frame), frame_(frame), xpath_(xpath) { }
+
+    virtual ~SwitchFrameValueParser() { }
+
+    virtual bool Parse(base::Value* value) const OVERRIDE {
+      if (value->IsType(Value::TYPE_NULL)) {
+        *found_frame_ = false;
+        return true;
+      }
+      ListValue* list;
+      if (!value->GetAsList(&list))
+        return false;
+      *found_frame_ = true;
+      return SetFromListValue(list, frame_, xpath_);
+    }
+
+   private:
+    bool* found_frame_;
+    WebElementId* frame_;
+    std::string* xpath_;
+  };
+
+  bool found_frame;
+  WebElementId new_frame_element;
+  std::string xpath;
+  Error* error = ExecuteScriptAndParse(
+      current_target_, script, "switchFrame", args,
+      new SwitchFrameValueParser(&found_frame, &new_frame_element, &xpath));
   if (error)
     return error;
 
-  ListValue* frame_and_xpath_list;
-  if (!result->GetAsList(&frame_and_xpath_list))
+  if (!found_frame)
     return new Error(kNoSuchFrame);
-  DictionaryValue* element_dict;
-  std::string xpath;
-  if (!frame_and_xpath_list->GetDictionary(0, &element_dict) ||
-      !frame_and_xpath_list->GetString(1, &xpath)) {
-    return new Error(
-        kUnknownError,
-        "Frame finding script did not return correct type: " +
-            JsonStringify(frame_and_xpath_list));
-  }
-  WebElementId new_frame_element(element_dict);
-  if (!new_frame_element.is_valid()) {
-    return new Error(
-        kUnknownError,
-        "Frame finding script did not return a frame element: " +
-            JsonStringify(element_dict));
-  }
 
   frame_elements_.push_back(new_frame_element);
   current_target_.frame_path = current_target_.frame_path.Append(xpath);
   return NULL;
 }
 
 Error* Session::FindElementsHelper(const FrameId& frame_id,
                                    const WebElementId& root_element,
                                    const std::string& locator,
                                    const std::string& query,
@@ skipping 48 matching lines @@
     done = done || elapsed_time > implicit_wait_;
     if (!done)
       base::PlatformThread::Sleep(50);  // Prevent a busy loop.
   }
 
   if (error.get())
     return error.release();
 
   // Parse the results.
   const std::string kInvalidElementDictionaryMessage =
-      "Find element script returned invalid element dictionary: " +
+      "findElement script returned invalid element dictionary: " +
           JsonStringify(value.get());
-  if (value->IsType(Value::TYPE_LIST)) {
-    ListValue* element_list = static_cast<ListValue*>(value.get());
+  if (find_one) {
+    WebElementId element;
+    if (!SetFromValue(value.get(), &element))
+      return new Error(kUnknownError, kInvalidElementDictionaryMessage);
+    elements->push_back(element);
+  } else {
+    ListValue* element_list;
+    if (!value->GetAsList(&element_list)) {
+      return new Error(
+          kUnknownError,
+          "findElements script returned unsupported type: " +
+              JsonStringify(value.get()));
+    }
     for (size_t i = 0; i < element_list->GetSize(); ++i) {
-      DictionaryValue* element_dict = NULL;
-      if (!element_list->GetDictionary(i, &element_dict)) {
-        return new Error(
-            kUnknownError,
-            "Find element script returned non-dictionary: " +
-                JsonStringify(element_list));
-      }
-
-      WebElementId element(element_dict);
-      if (!element.is_valid()) {
+      WebElementId element;
+      if (!SetFromValue(value.get(), &element))
         return new Error(kUnknownError, kInvalidElementDictionaryMessage);
-      }
       elements->push_back(element);
     }
-  } else if (value->IsType(Value::TYPE_DICTIONARY)) {
-    DictionaryValue* element_dict =
-        static_cast<DictionaryValue*>(value.get());
-    WebElementId element(element_dict);
-    if (!element.is_valid()) {
-      return new Error(kUnknownError, kInvalidElementDictionaryMessage);
-    }
-    elements->push_back(element);
-  } else {
-    return new Error(
-        kUnknownError,
-        "Find element script returned unsupported type: " +
-            JsonStringify(value.get()));
   }
   return NULL;
 }
 
 Error* Session::GetElementRegionInViewHelper(
     const FrameId& frame_id,
     const WebElementId& element,
-    const gfx::Rect& region,
+    const Rect& region,
     bool center,
-    gfx::Point* location) {
-  std::string jscript = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_LOCATION_IN_VIEW);
-  ListValue jscript_args;
-  jscript_args.Append(element.ToValue());
-  jscript_args.Append(Value::CreateBooleanValue(center));
-  DictionaryValue* elem_offset_dict = new DictionaryValue();
-  elem_offset_dict->SetInteger("left", region.x());
-  elem_offset_dict->SetInteger("top", region.y());
-  elem_offset_dict->SetInteger("width", region.width());
-  elem_offset_dict->SetInteger("height", region.height());
-  jscript_args.Append(elem_offset_dict);
-  Value* unscoped_value = NULL;
-  Error* error = ExecuteScript(frame_id, jscript, &jscript_args,
-                               &unscoped_value);
-  scoped_ptr<Value> value(unscoped_value);
-  if (error)
-    return error;
-  if (!value->IsType(Value::TYPE_DICTIONARY)) {
-    return new Error(
-        kUnknownError,
-        "Location atom returned non-dictionary type: " +
-            JsonStringify(value.get()));
-  }
-  DictionaryValue* loc_dict = static_cast<DictionaryValue*>(value.get());
-  int x = 0, y = 0;
-  if (!loc_dict->GetInteger("x", &x) ||
-      !loc_dict->GetInteger("y", &y)) {
-    return new Error(
-        kUnknownError,
-        "Location atom returned bad coordinate dictionary: " +
-            JsonStringify(loc_dict));
-  }
-  *location = gfx::Point(x, y);
-  return NULL;
+    Point* location) {
+  return ExecuteScriptAndParse(frame_id,
+                               atoms::GET_LOCATION_IN_VIEW,
+                               "getLocationInView",
+                               CreateListValueFrom(element, center, region),
+                               CreateDirectValueParser(location));
 }
 
 Error* Session::GetScreenShot(std::string* png) {
   Error* error = NULL;
   ScopedTempDir screenshots_dir;
   if (!screenshots_dir.CreateUniqueTempDir()) {
     return new Error(kUnknownError,
                      "Could not create temp directory for screenshot");
   }
 
   FilePath path = screenshots_dir.path().AppendASCII("screen");
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::CaptureEntirePageAsPNG,
       current_target_.window_id,
       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