ui: events: Add a class to hold common touch and stylus properties

ui/events/test/event_generator.cc

 // Copyright 2014 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 "ui/events/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 44 matching lines @@
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int touch_id,
                  int flags,
                  base::TimeDelta timestamp)
-      : TouchEvent(type, root_location, flags, touch_id, timestamp,
-                   1.0f, 1.0f, 0.0f, 0.0f) {
-  }
+      : TouchEvent(type,
+                   root_location,
+                   flags,
+                   touch_id,
+                   timestamp,
+                   0.0f,
+                   PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                       1.0f,
+                                       1.0f,
+                                       0.0f,
+                                       0.0f,
+                                       0.0f)) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
 EventGeneratorDelegate* EventGenerator::default_delegate = NULL;
@@ skipping 74 matching lines @@
 void EventGenerator::PressRightButton() {
   PressButton(ui::EF_RIGHT_MOUSE_BUTTON);
 }
 
 void EventGenerator::ReleaseRightButton() {
   ReleaseButton(ui::EF_RIGHT_MOUSE_BUTTON);
 }
 
 void EventGenerator::MoveMouseWheel(int delta_x, int delta_y) {
   gfx::Point location = GetLocationInCurrentRoot();
-  ui::MouseEvent mouseev(ui::ET_MOUSEWHEEL, location, location,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(
+      ui::ET_MOUSEWHEEL, location, location, ui::EventTimeForNow(), flags_, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   ui::MouseWheelEvent wheelev(mouseev, delta_x, delta_y);
   Dispatch(&wheelev);
 }
 
 void EventGenerator::SendMouseExit() {
   gfx::Point exit_location(current_location_);
   delegate()->ConvertPointToTarget(current_target_, &exit_location);
-  ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, exit_location, exit_location,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(
+      ui::ET_MOUSE_EXITED, exit_location, exit_location, ui::EventTimeForNow(),
+      flags_, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   Dispatch(&mouseev);
 }
 
 void EventGenerator::MoveMouseToWithNative(const gfx::Point& point_in_host,
                                            const gfx::Point& point_for_native) {
 #if defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitMotionEvent(point_in_host, point_for_native, flags_);
   static_cast<XEvent*>(xevent)->xmotion.time = Now().InMicroseconds();
   ui::MouseEvent mouseev(xevent);
 #elif defined(USE_OZONE)
   // Ozone uses the location in native event as a system location.
   // Create a fake event with the point in host, which will be passed
   // to the non native event, then update the native event with the native
   // (root) one.
   scoped_ptr<ui::MouseEvent> native_event(new ui::MouseEvent(
-      ui::ET_MOUSE_MOVED, point_in_host, point_in_host, Now(), flags_, 0));
+      ui::ET_MOUSE_MOVED, point_in_host, point_in_host, Now(), flags_, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ui::MouseEvent mouseev(native_event.get());
   native_event->set_location(point_for_native);
 #else
-  ui::MouseEvent mouseev(ui::ET_MOUSE_MOVED, point_in_host, point_for_native,
-                         Now(), flags_, 0);
+  ui::MouseEvent mouseev(
+      ui::ET_MOUSE_MOVED, point_in_host, point_for_native, Now(), flags_, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   LOG(FATAL)
       << "Generating a native motion event is not supported on this platform";
 #endif
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
   delegate()->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
-  ui::MouseEvent mouseev(event_type, point_in_host, point_in_host,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(
+      event_type, point_in_host, point_in_host, ui::EventTimeForNow(), flags_,
+      0, ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
   delegate()->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseTo(const gfx::Point& point_in_screen,
                                  int count) {
   DCHECK_GT(count, 0);
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
 
   gfx::Vector2dF diff(point_in_screen - current_location_);
   for (float i = 1; i <= count; i++) {
     gfx::Vector2dF step(diff);
     step.Scale(i / count);
     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
     if (!grab_)
       UpdateCurrentDispatcher(move_point);
     delegate()->ConvertPointToTarget(current_target_, &move_point);
-    ui::MouseEvent mouseev(event_type, move_point, move_point,
-                           ui::EventTimeForNow(), flags_, 0);
+    ui::MouseEvent mouseev(
+        event_type, move_point, move_point, ui::EventTimeForNow(), flags_, 0,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     Dispatch(&mouseev);
   }
   current_location_ = point_in_screen;
 }
 
 void EventGenerator::MoveMouseRelativeTo(const EventTarget* window,
                                          const gfx::Point& point_in_parent) {
   gfx::Point point(point_in_parent);
   delegate()->ConvertPointFromTarget(window, &point);
   MoveMouseTo(point);
@@ skipping 357 matching lines @@
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
   current_target_ = delegate()->GetTargetAt(point);
 }
 
 void EventGenerator::PressButton(int flag) {
   if (!(flags_ & flag)) {
     flags_ |= flag;
     grab_ = (flags_ & kAllButtonMask) != 0;
     gfx::Point location = GetLocationInCurrentRoot();
-    ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location,
-                           ui::EventTimeForNow(), flags_, flag);
+    ui::MouseEvent mouseev(
+        ui::ET_MOUSE_PRESSED, location, location, ui::EventTimeForNow(), flags_,
+        flag,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     Dispatch(&mouseev);
   }
 }
 
 void EventGenerator::ReleaseButton(int flag) {
   if (flags_ & flag) {
     gfx::Point location = GetLocationInCurrentRoot();
-    ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, location, location,
-                           ui::EventTimeForNow(), flags_, flag);
+    ui::MouseEvent mouseev(
+        ui::ET_MOUSE_RELEASED, location, location, ui::EventTimeForNow(),
+        flags_, flag,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     Dispatch(&mouseev);
     flags_ ^= flag;
   }
   grab_ = (flags_ & kAllButtonMask) != 0;
 }
 
 gfx::Point EventGenerator::GetLocationInCurrentRoot() const {
   gfx::Point p(current_location_);
   delegate()->ConvertPointToTarget(current_target_, &p);
   return p;
@@ skipping 57 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui