Replace touch 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"
+#include "cc/output/begin_frame_args.h"
 
 namespace content {
 
 namespace {
 
 SyntheticPointerActionParams::PointerActionType ToSyntheticPointerActionType(
     std::string action_type) {
   if (action_type == "pointerDown")
     return SyntheticPointerActionParams::PointerActionType::PRESS;
   if (action_type == "pointerMove")
@@ skipping 103 matching lines @@
     return false;
   }
 
   const base::ListValue* actions;
   if (!pointer.GetList("actions", &actions)) {
     error_message_ = base::StringPrintf(
         "pointer[%d].actions is missing or not a list", action_index_);
     return false;
   }
 
-  if (actions->GetSize() > longest_action_sequence_)
-    longest_action_sequence_ = actions->GetSize();
-
   if (!ParseActions(*actions))
     return false;
 
   return true;
 }
 
 bool ActionsParser::ParseActions(const base::ListValue& actions) {
   SyntheticPointerActionListParams::ParamList param_list;
   for (const auto& action_value : actions) {
     const base::DictionaryValue* action;
     if (!action_value->GetAsDictionary(&action)) {
       error_message_ = base::StringPrintf(
           "actions[%d].actions is missing or not a dictionary", action_index_);
       return false;
     } else if (!ParseAction(*action, param_list)) {
       return false;
     }
   }
+
+  if (param_list.size() > longest_action_sequence_)
+    longest_action_sequence_ = param_list.size();
+
   pointer_actions_list_.push_back(param_list);
   return true;
 }
 
 bool ActionsParser::ParseAction(
     const base::DictionaryValue& action,
     SyntheticPointerActionListParams::ParamList& param_list) {
   SyntheticPointerActionParams::PointerActionType pointer_action_type =
       SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED;
   std::string name;
@@ skipping 18 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;
   }
 
+  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));
   }
   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