Add PointerDetails to ui::MouseEvent's constructors

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 151 matching lines @@
 void EventGenerator::MoveMouseWheel(int delta_x, int delta_y) {
   gfx::Point location = GetLocationInCurrentRoot();
   ui::MouseWheelEvent wheelev(gfx::Vector2d(delta_x, delta_y), location,
                               location, ui::EventTimeForNow(), flags_, 0);
   Dispatch(&wheelev);
 }
 
 void EventGenerator::SendMouseEnter() {
   gfx::Point enter_location(current_location_);
   delegate()->ConvertPointToTarget(current_target_, &enter_location);
-  ui::MouseEvent mouseev(ui::ET_MOUSE_ENTERED, enter_location, enter_location,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(
+      ui::ET_MOUSE_ENTERED, enter_location, enter_location,
+      ui::EventTimeForNow(), flags_, 0,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                         ui::PointerEvent::kMousePointerId));
   Dispatch(&mouseev);
 }
 
 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::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                         ui::PointerEvent::kMousePointerId));
   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 =
       (ui::EventTimeForNow() - base::TimeTicks()).InMilliseconds() & UINT32_MAX;
   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.
-  std::unique_ptr<ui::MouseEvent> native_event(
-      new ui::MouseEvent(ui::ET_MOUSE_MOVED, point_in_host, point_in_host,
-                         ui::EventTimeForNow(), flags_, 0));
+  std::unique_ptr<ui::MouseEvent> native_event(new ui::MouseEvent(
+      ui::ET_MOUSE_MOVED, point_in_host, point_in_host, ui::EventTimeForNow(),
+      flags_, 0,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                         ui::PointerEvent::kMousePointerId)));
   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,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(
+      ui::ET_MOUSE_MOVED, point_in_host, point_for_native,
+      ui::EventTimeForNow(), flags_, 0,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                         ui::PointerEvent::kMousePointerId));
   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::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                         ui::PointerEvent::kMousePointerId));
   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::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                           ui::PointerEvent::kMousePointerId));
     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 405 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::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                           ui::PointerEvent::kMousePointerId));
     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::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
+                           ui::PointerEvent::kMousePointerId));
     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 76 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui