WebMouseEvent coordinates are now fractional & private

content/browser/renderer_host/render_widget_host_view_event_handler.cc

 // Copyright 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/browser/renderer_host/render_widget_host_view_event_handler.h"
 
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "content/browser/renderer_host/input/touch_selection_controller_client_aura.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
@@ skipping 703 matching lines @@
     synthetic_move_sent_ = true;
     window_->MoveCursorTo(center);
     return;
   }
 
   blink::WebMouseEvent mouse_event =
       ui::MakeWebMouseEvent(*event, base::Bind(&GetScreenLocationFromEvent));
 
   bool is_move_to_center_event = (event->type() == ui::ET_MOUSE_MOVED ||
                                   event->type() == ui::ET_MOUSE_DRAGGED) &&
-                                 mouse_event.x == center.x() &&
-                                 mouse_event.y == center.y();
+                                 mouse_event.position.x == center.x() &&
+                                 mouse_event.position.y == center.y();
 
   // For fractional scale factors, the conversion from pixels to dip and
   // vice versa could result in off by 1 or 2 errors which hurts us because
   // we want to avoid sending the artificial move to center event to the
   // renderer. Sending the move to center to the renderer cause the cursor
   // to bounce around the center of the screen leading to the lock operation
   // not working correctly.
   // Workaround is to treat a mouse move or drag event off by at most 2 px
   // from the center as a move to center event.
   if (synthetic_move_sent_ &&
       IsFractionalScaleFactor(host_view_->current_device_scale_factor())) {
     if (event->type() == ui::ET_MOUSE_MOVED ||
         event->type() == ui::ET_MOUSE_DRAGGED) {
-      if ((abs(mouse_event.x - center.x()) <= 2) &&
-          (abs(mouse_event.y - center.y()) <= 2)) {
+      if ((std::abs(mouse_event.position.x - center.x()) <= 2) &&
+          (std::abs(mouse_event.position.y - center.y()) <= 2)) {
         is_move_to_center_event = true;
       }
     }
   }
 
   ModifyEventMovementAndCoords(*event, &mouse_event);
 
   bool should_not_forward = is_move_to_center_event && synthetic_move_sent_;
   if (should_not_forward) {
     synthetic_move_sent_ = false;
@@ skipping 21 matching lines @@
   }
 }
 
 void RenderWidgetHostViewEventHandler::ModifyEventMovementAndCoords(
     const ui::MouseEvent& ui_mouse_event,
     blink::WebMouseEvent* event) {
   // If the mouse has just entered, we must report zero movementX/Y. Hence we
   // reset any global_mouse_position set previously.
   if (ui_mouse_event.type() == ui::ET_MOUSE_ENTERED ||
       ui_mouse_event.type() == ui::ET_MOUSE_EXITED) {
-    global_mouse_position_.SetPoint(event->globalX, event->globalY);
+    global_mouse_position_.SetPoint(event->screenPosition.x,
+                                    event->screenPosition.y);
   }
 
   // Movement is computed by taking the difference of the new cursor position
   // and the previous. Under mouse lock the cursor will be warped back to the
   // center so that we are not limited by clipping boundaries.
   // We do not measure movement as the delta from cursor to center because
   // we may receive more mouse movement events before our warp has taken
   // effect.
-  event->movementX = event->globalX - global_mouse_position_.x();
-  event->movementY = event->globalY - global_mouse_position_.y();
+  event->movementX = event->screenPosition.x - global_mouse_position_.x();
+  event->movementY = event->screenPosition.y - global_mouse_position_.y();
 
-  global_mouse_position_.SetPoint(event->globalX, event->globalY);
+  global_mouse_position_.SetPoint(event->screenPosition.x,
+                                  event->screenPosition.y);
 
   // Under mouse lock, coordinates of mouse are locked to what they were when
   // mouse lock was entered.
   if (mouse_locked_) {
-    event->x = unlocked_mouse_position_.x();
-    event->y = unlocked_mouse_position_.y();
-    event->globalX = unlocked_global_mouse_position_.x();
-    event->globalY = unlocked_global_mouse_position_.y();
+    event->position.x = unlocked_mouse_position_.x();
+    event->position.y = unlocked_mouse_position_.y();
+    event->screenPosition.x = unlocked_global_mouse_position_.x();
+    event->screenPosition.y = unlocked_global_mouse_position_.y();
   } else {
-    unlocked_mouse_position_.SetPoint(event->x, event->y);
-    unlocked_global_mouse_position_.SetPoint(event->globalX, event->globalY);
+    unlocked_mouse_position_.SetPoint(event->position.x, event->position.y);
+    unlocked_global_mouse_position_.SetPoint(event->screenPosition.x,
+                                             event->screenPosition.y);
   }
 }
 
 void RenderWidgetHostViewEventHandler::SetKeyboardFocus() {
 #if defined(OS_WIN)
   if (window_ && window_->delegate()->CanFocus()) {
     aura::WindowTreeHost* host = window_->GetHost();
     if (host) {
       gfx::AcceleratedWidget hwnd = host->GetAcceleratedWidget();
       if (!(::GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_NOACTIVATE))
@@ skipping 60 matching lines @@
   host_->ForwardWheelEventWithLatencyInfo(event, latency);
 }
 
 void RenderWidgetHostViewEventHandler::ProcessTouchEvent(
     const blink::WebTouchEvent& event,
     const ui::LatencyInfo& latency) {
   host_->ForwardTouchEventWithLatencyInfo(event, latency);
 }
 
 }  // namespace content