Add SyntheticPointerActionParams used in Chromedriver extension

content/common/input/input_param_traits_unittest.cc

 // Copyright 2013 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/common/input/input_param_traits.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "content/common/input/input_event.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
+#include "content/common/input/synthetic_pointer_action_params.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input_messages.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace content {
 namespace {
 
@@ skipping 47 matching lines @@
               b->relative_pointer_speed_in_pixels_s);
   }
 
   static void Compare(const SyntheticTapGestureParams* a,
                       const SyntheticTapGestureParams* b) {
     EXPECT_EQ(a->gesture_source_type, b->gesture_source_type);
     EXPECT_EQ(a->position, b->position);
     EXPECT_EQ(a->duration_ms, b->duration_ms);
   }
 
+  static void Compare(const SyntheticPointerActionParams* a,
+                      const SyntheticPointerActionParams* b) {
+    EXPECT_EQ(a->gesture_source_type, b->gesture_source_type);
+    EXPECT_EQ(a->position(), b->position());

[tdresser, 2016/03/23 15:09:25]

Won't this fail for some types, due to the assertions?

[samuong, 2016/03/29 20:51:25]

Not sure if I'm talking about the same issue as Tim, but the position is a
gfx::PointF, which contains floats. Will this work reliably? Should
EXPECT_FLOAT_EQ be used instead?

[tdresser, 2016/03/30 13:52:22]

That's separate from what I'm referring to (there are DCHECKs that we don't read
the position() depending on the type of the SyntheticPointerActionParams).
You're right that we should probably be using EXPECT_FLOAT_EQ, thanks.

[lanwei, 2016/03/30 21:02:53]

I checked the definition of EXPECT_EQ, it uses PointF's compare function, so it
is as good as EXPECT_FLOAT_EQ, thanks.

[lanwei, 2016/03/30 21:02:53]

Thanks for catching this, I added the constraint when compare them.

[tdresser, 2016/03/31 12:25:31]

The fact that we didn't catch this in any automated tests is a bit scary. Should
we add a bit of additional test coverage?

+    EXPECT_EQ(a->index(), b->index());
+    EXPECT_EQ(a->pointer_action_type(), b->pointer_action_type());
+  }
+
   static void Compare(const SyntheticGesturePacket* a,
                       const SyntheticGesturePacket* b) {
     ASSERT_EQ(!!a, !!b);
     if (!a) return;
     ASSERT_EQ(!!a->gesture_params(), !!b->gesture_params());
     if (!a->gesture_params()) return;
     ASSERT_EQ(a->gesture_params()->GetGestureType(),
               b->gesture_params()->GetGestureType());
     switch (a->gesture_params()->GetGestureType()) {
       case SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
         Compare(SyntheticSmoothScrollGestureParams::Cast(a->gesture_params()),
                 SyntheticSmoothScrollGestureParams::Cast(b->gesture_params()));
         break;
       case SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
         Compare(SyntheticSmoothDragGestureParams::Cast(a->gesture_params()),
                 SyntheticSmoothDragGestureParams::Cast(b->gesture_params()));
         break;
       case SyntheticGestureParams::PINCH_GESTURE:
         Compare(SyntheticPinchGestureParams::Cast(a->gesture_params()),
                 SyntheticPinchGestureParams::Cast(b->gesture_params()));
         break;
       case SyntheticGestureParams::TAP_GESTURE:
         Compare(SyntheticTapGestureParams::Cast(a->gesture_params()),
                 SyntheticTapGestureParams::Cast(b->gesture_params()));
         break;
+      case SyntheticGestureParams::POINTER_ACTION:
+        Compare(SyntheticPointerActionParams::Cast(a->gesture_params()),
+                SyntheticPointerActionParams::Cast(b->gesture_params()));
+        break;
     }
   }
 
   static void Verify(const InputEvents& events_in) {
     IPC::Message msg;
     IPC::ParamTraits<InputEvents>::Write(&msg, events_in);
 
     InputEvents events_out;
     base::PickleIterator iter(msg);
     EXPECT_TRUE(IPC::ParamTraits<InputEvents>::Read(&msg, &iter, &events_out));
@@ skipping 128 matching lines @@
   gesture_params->position.SetPoint(798, 233);
   gesture_params->duration_ms = 13;
   ASSERT_EQ(SyntheticGestureParams::TAP_GESTURE,
             gesture_params->GetGestureType());
   SyntheticGesturePacket packet_in;
   packet_in.set_gesture_params(std::move(gesture_params));
 
   Verify(packet_in);
 }
 
+TEST_F(InputParamTraitsTest, SyntheticPointerActionParams) {
+  scoped_ptr<SyntheticPointerActionParams> gesture_params(
+      new SyntheticPointerActionParams(
+          SyntheticPointerActionParams::PointerActionType::MOVE));
+  gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  gesture_params->set_position(gfx::PointF(356, 287));
+  gesture_params->set_index(0);
+  ASSERT_EQ(SyntheticGestureParams::POINTER_ACTION,
+            gesture_params->GetGestureType());
+  SyntheticGesturePacket packet_in;
+  packet_in.set_gesture_params(std::move(gesture_params));
+  Verify(packet_in);
+}
+
 }  // namespace
 }  // namespace content