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

chrome/test/webdriver/commands/mouse_commands.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/commands/mouse_commands.h"
 
 #include "base/values.h"
 #include "chrome/common/automation_constants.h"
+#include "chrome/test/automation/value_conversion_util.h"
 #include "chrome/test/webdriver/commands/response.h"
 #include "chrome/test/webdriver/session.h"
-#include "chrome/test/webdriver/utility_functions.h"
 #include "chrome/test/webdriver/web_element_id.h"
+#include "chrome/test/webdriver/webdriver_basic_types.h"
 #include "chrome/test/webdriver/webdriver_error.h"
-#include "ui/gfx/point.h"
-#include "ui/gfx/size.h"
+#include "chrome/test/webdriver/webdriver_util.h"
 
 namespace {
 
 const int kLeftButton = 0;
 const int kMiddleButton = 1;
 const int kRightButton = 2;
 
 }  // namespace
 
 namespace webdriver {
@@ skipping 13 matching lines @@
   std::string tag_name;
   Error* error = session_->GetElementTagName(
       session_->current_target(), element, &tag_name);
   if (error) {
     response->SetError(error);
     return;
   }
 
   if (tag_name == "option") {
     const char* kCanOptionBeToggledScript =
-        "return (function(option) {"
+        "function(option) {"
         "  var select = option.parentElement;"
         "  if (!select || select.tagName.toLowerCase() != 'select')"
         "    throw new Error('Option element is not in a select');"
         "  return select.multiple;"
-        "}).apply(null, arguments);";
-    ListValue args;
-    args.Append(element.ToValue());
-    Value* value = NULL;
-    error = session_->ExecuteScript(
-        session_->current_target(), kCanOptionBeToggledScript, &args, &value);
+        "}";
+    bool can_be_toggled;
+    error = session_->ExecuteScriptAndParse(
+        session_->current_target(),
+        kCanOptionBeToggledScript,
+        "canOptionBeToggled",
+        CreateListValueFrom(element),
+        CreateDirectValueParser(&can_be_toggled));
     if (error) {
       response->SetError(error);
       return;
     }
-    scoped_ptr<Value> scoped_value(value);
-    bool can_be_toggled;
-    if (!value->GetAsBoolean(&can_be_toggled)) {
-      response->SetError(
-          new Error(kUnknownError, "canOptionBeToggled returned non-boolean: " +
-                        JsonStringify(value)));
-      return;
-    }
 
     if (can_be_toggled) {
       error = session_->ToggleOptionElement(
           session_->current_target(), element);
     } else {
       error = session_->SetOptionElementSelected(
           session_->current_target(), element, true);
     }
   } else {
-    gfx::Point location;
+    Point location;
     error = session_->GetClickableLocation(element, &location);
     if (!error)
       error = session_->MouseMoveAndClick(location, automation::kLeftButton);
   }
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 HoverCommand::HoverCommand(const std::vector<std::string>& path_segments,
                            const DictionaryValue* const parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 HoverCommand::~HoverCommand() {}
 
 bool HoverCommand::DoesPost() {
   return true;
 }
 
 void HoverCommand::ExecutePost(Response* response) {
   Error* error = NULL;
-  gfx::Point location;
+  Point location;
   error = session_->GetClickableLocation(element, &location);
   if (!error)
     error = session_->MouseMove(location);
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 DragCommand::DragCommand(const std::vector<std::string>& path_segments,
@@ skipping 14 matching lines @@
 
   return true;
 }
 
 bool DragCommand::DoesPost() {
   return true;
 }
 
 void DragCommand::ExecutePost(Response* response) {
   Error* error = NULL;
-  gfx::Point drag_from;
+  Point drag_from;
   error = session_->GetClickableLocation(element, &drag_from);
   if (error) {
     response->SetError(error);
     return;
   }
 
-  gfx::Point drag_to(drag_from);
+  Point drag_to(drag_from);
   drag_to.Offset(drag_x_, drag_y_);
   if (drag_to.x() < 0 || drag_to.y() < 0)
     error = new Error(kBadRequest, "Invalid (x,y) coordinates");
   if (!error)
     error = session_->MouseDrag(drag_from, drag_to);
 
   if (error) {
     response->SetError(error);
     return;
   }
@@ skipping 35 matching lines @@
   if (!has_element_ && !has_offset_) {
     response->SetError(new Error(
         kBadRequest, "Invalid command arguments"));
     return false;
   }
 
   return true;
 }
 
 void MoveToCommand::ExecutePost(Response* const response) {
-  gfx::Point location;
+  Point location;
   Error* error;
 
   if (has_element_) {
     // If an element is specified, calculate the coordinate.
     error = session_->GetElementLocationInView(element_, &location);
     if (error) {
       response->SetError(error);
       return;
     }
   } else {
     // If not, use the current mouse position.
     location = session_->get_mouse_position();
   }
 
   if (has_offset_) {
     // If an offset is specified, translate by the offset.
     location.Offset(x_offset_, y_offset_);
   } else {
     DCHECK(has_element_);
 
     // If not, calculate the half of the element size and translate by it.
-    gfx::Size size;
+    Size size;
     error = session_->GetElementSize(session_->current_target(),
                                      element_, &size);
     if (error) {
       response->SetError(error);
       return;
     }
 
     location.Offset(size.width() / 2, size.height() / 2);
   }
 
@@ skipping 73 matching lines @@
 
 void DoubleClickCommand::ExecutePost(Response* const response) {
   Error* error = session_->MouseDoubleClick();
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 }  // namespace webdriver