WebMouseEvent coordinates are now fractional & private

content/shell/test_runner/event_sender.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 "content/shell/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 199 matching lines @@
                            int current_buttons,
                            const WebPoint& pos,
                            int click_count,
                            WebPointerProperties::PointerType pointerType,
                            int pointerId,
                            float pressure,
                            int tiltX,
                            int tiltY,
                            WebMouseEvent* e) {
   e->button = b;
-  e->x = pos.x;
-  e->y = pos.y;
-  e->globalX = pos.x;
-  e->globalY = pos.y;
+  e->position.x = pos.x;
+  e->position.y = pos.y;
+  e->screenPosition.x = pos.x;
+  e->screenPosition.y = pos.y;
   e->pointerType = pointerType;
   e->id = pointerId;
   e->force = pressure;
   e->tiltX = tiltX;
   e->tiltY = tiltY;
   e->clickCount = click_count;
 }
 
 void InitMouseEvent(WebMouseEvent::Button b,
                     int current_buttons,
                     const WebPoint& pos,
                     int click_count,
                     WebMouseEvent* e) {
   InitMouseEventGeneric(b, current_buttons, pos, click_count,
                         WebPointerProperties::PointerType::Mouse, 0, 0.0, 0, 0,
                         e);
 }
 
 void InitGestureEventFromMouseWheel(const WebMouseWheelEvent& wheel_event,
                                     WebGestureEvent* gesture_event) {
   gesture_event->sourceDevice = blink::WebGestureDeviceTouchpad;
-  gesture_event->x = wheel_event.x;
-  gesture_event->y = wheel_event.y;
-  gesture_event->globalX = wheel_event.globalX;
-  gesture_event->globalY = wheel_event.globalY;
+  gesture_event->x = wheel_event.position.x;
+  gesture_event->y = wheel_event.position.y;
+  gesture_event->globalX = wheel_event.screenPosition.x;
+  gesture_event->globalY = wheel_event.screenPosition.y;
 }
 
 int GetKeyModifier(const std::string& modifier_name) {
   const char* characters = modifier_name.c_str();
   if (!strcmp(characters, "ctrlKey")
 #ifndef __APPLE__
       || !strcmp(characters, "addSelectionKey")
 #endif
           ) {
     return WebInputEvent::ControlKey;
@@ skipping 1084 matching lines @@
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  click_count_, &raw_event);
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
-  WebPoint client_point(event->x, event->y);
-  WebPoint screen_point(event->globalX, event->globalY);
+  WebPoint client_point(event->position.x, event->position.y);
+  WebPoint screen_point(event->screenPosition.x, event->screenPosition.y);
   current_drag_data_ = drag_data;
   current_drag_effects_allowed_ = mask;
   current_drag_effect_ = mainFrameWidget()->dragTargetDragEnter(
       drag_data, client_point, screen_point, current_drag_effects_allowed_,
       modifiersWithButtons(
           current_pointer_state_[kRawMousePointerId].modifiers_,
           current_pointer_state_[kRawMousePointerId].current_buttons_));
 
   // Finish processing events.
   ReplaySavedEvents();
@@ skipping 1287 matching lines @@
 }
 
 void EventSender::FinishDragAndDrop(const WebMouseEvent& raw_event,
                                     blink::WebDragOperation drag_effect) {
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
-  WebPoint client_point(event->x, event->y);
-  WebPoint screen_point(event->globalX, event->globalY);
+  WebPoint client_point(event->position.x, event->position.y);
+  WebPoint screen_point(event->screenPosition.x, event->screenPosition.y);
   current_drag_effect_ = drag_effect;
   if (current_drag_effect_) {
     // Specifically pass any keyboard modifiers to the drop method. This allows
     // tests to control the drop type (i.e. copy or move).
     mainFrameWidget()->dragTargetDrop(current_drag_data_, client_point,
                                       screen_point, event->modifiers());
   } else {
     mainFrameWidget()->dragTargetDragLeave(blink::WebPoint(),
                                            blink::WebPoint());
   }
@@ skipping 10 matching lines @@
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
   last_click_time_sec_ = event->timeStampSeconds();
   last_click_pos_ = current_pointer_state_[kRawMousePointerId].last_pos_;
 
   // If we're in a drag operation, complete it.
   if (current_drag_data_.isNull())
     return;
 
-  WebPoint client_point(event->x, event->y);
-  WebPoint screen_point(event->globalX, event->globalY);
+  WebPoint client_point(event->position.x, event->position.y);
+  WebPoint screen_point(event->screenPosition.x, event->screenPosition.y);
   blink::WebDragOperation drag_effect = mainFrameWidget()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
       event->modifiers());
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
   FinishDragAndDrop(raw_event, drag_effect);
 }
 
 void EventSender::DoDragAfterMouseMove(const WebMouseEvent& raw_event) {
   if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::Button::NoButton ||
       current_drag_data_.isNull()) {
     return;
   }
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
-  WebPoint client_point(event->x, event->y);
-  WebPoint screen_point(event->globalX, event->globalY);
+  WebPoint client_point(event->position.x, event->position.y);
+  WebPoint screen_point(event->screenPosition.x, event->screenPosition.y);
   current_drag_effect_ = mainFrameWidget()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
       event->modifiers());
 }
 
 void EventSender::ReplaySavedEvents() {
   replaying_saved_events_ = true;
   while (!mouse_event_queue_.empty()) {
     SavedEvent e = mouse_event_queue_.front();
     mouse_event_queue_.pop_front();
 
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
         WebMouseEvent event(WebInputEvent::MouseMove,
                             ModifiersForPointer(kRawMousePointerId),
                             GetCurrentEventTimeSec());
         InitMouseEvent(
             current_pointer_state_[kRawMousePointerId].pressed_button_,
             current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos,
             click_count_, &event);
         current_pointer_state_[kRawMousePointerId].last_pos_ =
-            WebPoint(event.x, event.y);
+            WebPoint(event.position.x, event.position.y);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseMove(event);
         break;
       }
       case SavedEvent::TYPE_LEAP_FORWARD:
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
         current_pointer_state_[kRawMousePointerId].current_buttons_ &=
             ~GetWebMouseEventModifierForButton(e.button_type);
@@ skipping 126 matching lines @@
   return view()->mainFrame()->toWebLocalFrame()->frameWidget();
 }
 
 std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates(
     const WebInputEvent& event) {
   return delegate()->TransformScreenToWidgetCoordinates(
       web_widget_test_proxy_base_, event);
 }
 
 }  // namespace test_runner