Replace mouse actions in pointer event tests with pointerActionSequence

content/renderer/gpu/actions_parser.cc

 // Copyright (c) 2016 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 "content/renderer/gpu/actions_parser.h"
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 19 matching lines @@
 SyntheticGestureParams::GestureSourceType ToSyntheticGestureSourceType(
     std::string source_type) {
   if (source_type == "touch")
     return SyntheticGestureParams::TOUCH_INPUT;
   else if (source_type == "mouse")
     return SyntheticGestureParams::MOUSE_INPUT;
   else
     return SyntheticGestureParams::DEFAULT_INPUT;
 }
 
+SyntheticPointerActionParams::Button ToSyntheticMouseButton(
+    std::string button) {
+  if (button == "left")
+    return SyntheticPointerActionParams::Button::LEFT;
+  else if (button == "middle")
+    return SyntheticPointerActionParams::Button::MIDDLE;
+  else

[tdresser, 2017/01/19 14:41:57]

Let's be explicit here, DCHECK if the string isn't correct.

+    return SyntheticPointerActionParams::Button::RIGHT;
+}
+
 }  // namespace
 
 ActionsParser::ActionsParser(base::Value* pointer_actions_value)
     : longest_action_sequence_(0),
       pointer_actions_value_(pointer_actions_value),
       action_index_(0) {}
 
 ActionsParser::~ActionsParser() {}
 
 bool ActionsParser::ParsePointerActionSequence() {
@@ skipping 135 matching lines @@
                                         action_index_);
     return false;
   }
 
   if (action.HasKey("y") && !action.GetDouble("y", &position_y)) {
     error_message_ = base::StringPrintf("actions[%d].actions.y is not a number",
                                         action_index_);
     return false;
   }
 
+  std::string button_name = "left";
+  if (action.HasKey("button") && !action.GetString("button", &button_name)) {
+    error_message_ = base::StringPrintf(
+        "actions[%d].actions.button is not a string", action_index_);
+    return false;
+  } else if (button_name != "left" && button_name != "middle" &&
+             button_name != "right") {
+    error_message_ = base::StringPrintf(
+        "actions[%d].actions.button is an unsupported button", action_index_);
+    return false;
+  }
+  SyntheticPointerActionParams::Button button =
+      ToSyntheticMouseButton(button_name);
+
   double duration = 0;
   int num_idle = 0;
   if (pointer_action_type ==
       SyntheticPointerActionParams::PointerActionType::IDLE) {
     num_idle = 1;
     if (action.HasKey("duration") && !action.GetDouble("duration", &duration)) {
       error_message_ = base::StringPrintf(
           "actions[%d].actions.x is not a number", action_index_);
       return false;
     }
   }
 
   // If users pause for given seconds, we convert to the number of idle frames.
   if (duration > 0) {
     num_idle = static_cast<int>(std::ceil(
         duration / cc::BeginFrameArgs::DefaultInterval().InSecondsF()));
   }
 
   SyntheticPointerActionParams action_param(pointer_action_type);
   action_param.set_index(action_index_);
-  if (pointer_action_type ==
-          SyntheticPointerActionParams::PointerActionType::PRESS ||
-      pointer_action_type ==
-          SyntheticPointerActionParams::PointerActionType::MOVE) {
-    action_param.set_position(gfx::PointF(position_x, position_y));
+  switch (pointer_action_type) {
+    case SyntheticPointerActionParams::PointerActionType::PRESS:
+      action_param.set_position(gfx::PointF(position_x, position_y));
+      action_param.set_button(button);
+      break;
+    case SyntheticPointerActionParams::PointerActionType::MOVE:
+      action_param.set_position(gfx::PointF(position_x, position_y));
+      break;
+    case SyntheticPointerActionParams::PointerActionType::RELEASE:
+      action_param.set_button(button);
+      break;
+    case SyntheticPointerActionParams::PointerActionType::IDLE:
+    case SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED:
+      break;
   }
   param_list.push_back(action_param);
 
   // We queue all the IDLE actions in the action parameter list to make sure we
   // will pause long enough on the given pointer.
   for (int count = 1; count < num_idle; ++count)
     param_list.push_back(action_param);
 
   return true;
 }
 
 }  // namespace content