WebMouseEvent coordinates are now fractional & private

ui/events/blink/web_input_event_builders_win.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 "ui/events/blink/web_input_event_builders_win.h"
 
 #include "ui/display/win/screen_win.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/event_utils.h"
 
@@ skipping 152 matching lines @@
     modifiers |= WebInputEvent::MiddleButtonDown;
   if (wparam & MK_RBUTTON)
     modifiers |= WebInputEvent::RightButtonDown;
 
   WebMouseEvent result(type, modifiers, time_stamp);
   result.pointerType = pointer_type;
   result.button = button;
   result.id = ui::PointerEvent::kMousePointerId;
 
   // set position fields:
-  result.x = static_cast<short>(LOWORD(lparam));
-  result.y = static_cast<short>(HIWORD(lparam));
+  result.setPositionInWidget(static_cast<short>(LOWORD(lparam)),
+                             static_cast<short>(HIWORD(lparam)));
 
-  POINT global_point = {result.x, result.y};
+  POINT global_point = {result.positionInWidget().x,
+                        result.positionInWidget().y};
   ClientToScreen(hwnd, &global_point);
 
   // We need to convert the global point back to DIP before using it.
   gfx::Point dip_global_point = display::win::ScreenWin::ScreenToDIPPoint(
       gfx::Point(global_point.x, global_point.y));
 
-  result.globalX = dip_global_point.x();
-  result.globalY = dip_global_point.y();
+  result.setPositionInScreen(dip_global_point.x(), dip_global_point.y());
 
   // calculate number of clicks:
 
   // This differs slightly from the WebKit code in WebKit/win/WebView.cpp
   // where their original code looks buggy.
   static int last_click_position_x;
   static int last_click_position_y;
   static WebMouseEvent::Button last_click_button = WebMouseEvent::Button::Left;
 
   double current_time = result.timeStampSeconds();
   bool cancel_previous_click =
-      (abs(last_click_position_x - result.x) >
+      (abs(last_click_position_x - result.positionInWidget().x) >
        (::GetSystemMetrics(SM_CXDOUBLECLK) / 2)) ||
-      (abs(last_click_position_y - result.y) >
+      (abs(last_click_position_y - result.positionInWidget().y) >
        (::GetSystemMetrics(SM_CYDOUBLECLK) / 2)) ||
       ((current_time - g_last_click_time) * 1000.0 > ::GetDoubleClickTime());
 
   if (result.type() == WebInputEvent::MouseDown) {
     if (!cancel_previous_click && (result.button == last_click_button)) {
       ++g_last_click_count;
     } else {
       g_last_click_count = 1;
-      last_click_position_x = result.x;
-      last_click_position_y = result.y;
+      last_click_position_x = result.positionInWidget().x;
+      last_click_position_y = result.positionInWidget().y;
     }
     g_last_click_time = current_time;
     last_click_button = result.button;
   } else if (result.type() == WebInputEvent::MouseMove ||
              result.type() == WebInputEvent::MouseLeave) {
     if (cancel_previous_click) {
       g_last_click_count = 0;
       last_click_position_x = 0;
       last_click_position_y = 0;
       g_last_click_time = 0;
@@ skipping 33 matching lines @@
     key_state = 0;
     if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
       key_state |= MK_SHIFT;
     if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
       key_state |= MK_CONTROL;
     // NOTE: There doesn't seem to be a way to query the mouse button state
     // in this case.
 
     POINT cursor_position = {0};
     GetCursorPos(&cursor_position);
-    result.globalX = cursor_position.x;
-    result.globalY = cursor_position.y;
+    result.setPositionInScreen(cursor_position.x, cursor_position.y);
 
     switch (LOWORD(wparam)) {
       case SB_LINEUP:  // == SB_LINELEFT
         wheel_delta = WHEEL_DELTA;
         break;
       case SB_LINEDOWN:  // == SB_LINERIGHT
         wheel_delta = -WHEEL_DELTA;
         break;
       case SB_PAGEUP:
         wheel_delta = 1;
         result.scrollByPage = true;
         break;
       case SB_PAGEDOWN:
         wheel_delta = -1;
         result.scrollByPage = true;
         break;
       default:  // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here.
         wheel_delta = 0;
         break;
     }
 
     if (message == WM_HSCROLL)
       horizontal_scroll = true;
   } else {
     // Non-synthesized event; we can just read data off the event.
     key_state = GET_KEYSTATE_WPARAM(wparam);
 
-    result.globalX = static_cast<short>(LOWORD(lparam));
-    result.globalY = static_cast<short>(HIWORD(lparam));
+    result.setPositionInScreen(static_cast<short>(LOWORD(lparam)),
+                               static_cast<short>(HIWORD(lparam)));
 
     // Currently we leave hasPreciseScrollingDeltas false, even for trackpad
     // scrolls that generate WM_MOUSEWHEEL, since we don't have a good way to
     // distinguish these from real mouse wheels (crbug.com/545234).
     wheel_delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam));
 
     if (message == WM_MOUSEHWHEEL) {
       horizontal_scroll = true;
       wheel_delta = -wheel_delta;  // Windows is <- -/+ ->, WebKit <- +/- ->.
     }
   }
 
   // Set modifiers based on key state.
   int modifiers = result.modifiers();
   if (key_state & MK_SHIFT)
     modifiers |= WebInputEvent::ShiftKey;
   if (key_state & MK_CONTROL)
     modifiers |= WebInputEvent::ControlKey;
   if (key_state & MK_LBUTTON)
     modifiers |= WebInputEvent::LeftButtonDown;
   if (key_state & MK_MBUTTON)
     modifiers |= WebInputEvent::MiddleButtonDown;
   if (key_state & MK_RBUTTON)
     modifiers |= WebInputEvent::RightButtonDown;
   result.setModifiers(modifiers);
 
   // Set coordinates by translating event coordinates from screen to client.
-  POINT client_point = {result.globalX, result.globalY};
+  POINT client_point = {result.positionInScreen().x,
+                        result.positionInScreen().y};
   MapWindowPoints(0, hwnd, &client_point, 1);
-  result.x = client_point.x;
-  result.y = client_point.y;
+  result.setPositionInWidget(client_point.x, client_point.y);
 
   // Convert wheel delta amount to a number of pixels to scroll.
   //
   // How many pixels should we scroll per line?  Gecko uses the height of the
   // current line, which means scroll distance changes as you go through the
   // page or go to different pages.  IE 8 is ~60 px/line, although the value
   // seems to vary slightly by page and zoom level.  Also, IE defaults to
   // smooth scrolling while Firefox doesn't, so it can get away with somewhat
   // larger scroll values without feeling as jerky.  Here we use 100 px per
   // three lines (the default scroll amount is three lines per wheel tick).
@@ skipping 27 matching lines @@
     result.wheelTicksX = wheel_delta;
   } else {
     result.deltaY = scroll_delta;
     result.wheelTicksY = wheel_delta;
   }
 
   return result;
 }
 
 }  // namespace ui