WebMouseEvent coordinates are now fractional & private

content/browser/renderer_host/render_widget_host_input_event_router.cc

 // Copyright 2015 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_input_event_router.h"
 
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
 #include "cc/quads/surface_draw_quad.h"
@@ skipping 164 matching lines @@
   gfx::Point transformed_point;
 
   // When the mouse is locked, directly route the events to the widget that
   // holds the lock and return.
   if (root_view->IsMouseLocked()) {
     target = RenderWidgetHostImpl::From(root_view->GetRenderWidgetHost())
                  ->delegate()
                  ->GetMouseLockWidget()
                  ->GetView();
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), target, &transformed_point))
+            gfx::Point(event->position.x, event->position.y), target,
+            &transformed_point))
       return;
 
-    event->x = transformed_point.x();
-    event->y = transformed_point.y();
+    event->position.x = transformed_point.x();
+    event->position.y = transformed_point.y();
     target->ProcessMouseEvent(*event, latency);
     return;
   }
 
   const int mouse_button_modifiers = blink::WebInputEvent::LeftButtonDown |
                                      blink::WebInputEvent::MiddleButtonDown |
                                      blink::WebInputEvent::RightButtonDown;
   if (mouse_capture_target_.target &&
       event->type() != blink::WebInputEvent::MouseDown &&
       (event->type() == blink::WebInputEvent::MouseUp ||
        event->modifiers() & mouse_button_modifiers)) {
     target = mouse_capture_target_.target;
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), target, &transformed_point))
+            gfx::Point(event->position.x, event->position.y), target,
+            &transformed_point))
       return;
     if (event->type() == blink::WebInputEvent::MouseUp)
       mouse_capture_target_.target = nullptr;
   } else {
-    target = FindEventTarget(root_view, gfx::Point(event->x, event->y),
+    target = FindEventTarget(root_view,
+                             gfx::Point(event->position.x, event->position.y),
                              &transformed_point);
   }
 
   // RenderWidgetHostViewGuest does not properly handle direct routing of mouse
   // events, so they have to go by the double-hop forwarding path through
   // the embedding renderer and then BrowserPluginGuest.
   if (target && target->IsRenderWidgetHostViewGuest()) {
     ui::LatencyInfo latency_info;
     RenderWidgetHostViewBase* owner_view =
         static_cast<RenderWidgetHostViewGuest*>(target)
             ->GetOwnerRenderWidgetHostView();
     // In case there is nested RenderWidgetHostViewGuests (i.e., PDF inside
     // <webview>), we will need the owner view of the top-most guest for input
     // routing.
     while (owner_view->IsRenderWidgetHostViewGuest()) {
       owner_view = static_cast<RenderWidgetHostViewGuest*>(owner_view)
                        ->GetOwnerRenderWidgetHostView();
     }
 
     if (owner_view != root_view) {
       // This happens when the view is embedded inside a cross-process frame
       // (i.e., owner view is a RenderWidgetHostViewChildFrame).
       gfx::Point owner_point;
       if (!root_view->TransformPointToCoordSpaceForView(
-              gfx::Point(event->x, event->y), owner_view, &owner_point)) {
+              gfx::Point(event->position.x, event->position.y), owner_view,
+              &owner_point)) {
         return;
       }
-      event->x = owner_point.x();
-      event->y = owner_point.y();
+      event->position.x = owner_point.x();
+      event->position.y = owner_point.y();
     }
     owner_view->ProcessMouseEvent(*event, latency_info);
     return;
   }
 
   if (event->type() == blink::WebInputEvent::MouseDown)
     mouse_capture_target_.target = target;
 
   if (!target)
     return;
 
   // SendMouseEnterOrLeaveEvents is called with the original event
   // coordinates, which are transformed independently for each view that will
   // receive an event.
   if ((event->type() == blink::WebInputEvent::MouseLeave ||
        event->type() == blink::WebInputEvent::MouseMove) &&
       target != last_mouse_move_target_)
     SendMouseEnterOrLeaveEvents(event, target, root_view);
 
-  event->x = transformed_point.x();
-  event->y = transformed_point.y();
+  event->position.x = transformed_point.x();
+  event->position.y = transformed_point.y();
   target->ProcessMouseEvent(*event, latency);
 }
 
 void RenderWidgetHostInputEventRouter::RouteMouseWheelEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebMouseWheelEvent* event,
     const ui::LatencyInfo& latency) {
   RenderWidgetHostViewBase* target = nullptr;
   gfx::Point transformed_point;
 
   if (root_view->IsMouseLocked()) {
     target = RenderWidgetHostImpl::From(root_view->GetRenderWidgetHost())
                  ->delegate()
                  ->GetMouseLockWidget()
                  ->GetView();
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), target, &transformed_point))
+            gfx::Point(event->position.x, event->position.y), target,
+            &transformed_point))
       return;
   } else {
-    target = FindEventTarget(root_view, gfx::Point(event->x, event->y),
+    target = FindEventTarget(root_view,
+                             gfx::Point(event->position.x, event->position.y),
                              &transformed_point);
   }
 
   if (!target)
     return;
 
-  event->x = transformed_point.x();
-  event->y = transformed_point.y();
+  event->position.x = transformed_point.x();
+  event->position.y = transformed_point.y();
   target->ProcessMouseWheelEvent(*event, latency);
 }
 
 void RenderWidgetHostInputEventRouter::RouteGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   switch (event->sourceDevice) {
     case blink::WebGestureDeviceUninitialized:
       NOTREACHED() << "Uninitialized device type is not allowed";
@@ skipping 189 matching lines @@
   gfx::Point transformed_point;
   // Send MouseLeaves.
   for (auto* view : exited_views) {
     blink::WebMouseEvent mouse_leave(*event);
     mouse_leave.setType(blink::WebInputEvent::MouseLeave);
     // There is a chance of a race if the last target has recently created a
     // new compositor surface. The SurfaceID for that might not have
     // propagated to its embedding surface, which makes it impossible to
     // compute the transformation for it
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), view, &transformed_point))
+            gfx::Point(event->position.x, event->position.y), view,
+            &transformed_point))
       transformed_point = gfx::Point();
-    mouse_leave.x = transformed_point.x();
-    mouse_leave.y = transformed_point.y();
+    mouse_leave.position.x = transformed_point.x();
+    mouse_leave.position.y = transformed_point.y();
     view->ProcessMouseEvent(mouse_leave, ui::LatencyInfo());
   }
 
   // The ancestor might need to trigger MouseOut handlers.
   if (common_ancestor && common_ancestor != target) {
     blink::WebMouseEvent mouse_move(*event);
     mouse_move.setType(blink::WebInputEvent::MouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), common_ancestor,
+            gfx::Point(event->position.x, event->position.y), common_ancestor,
             &transformed_point))
       transformed_point = gfx::Point();
-    mouse_move.x = transformed_point.x();
-    mouse_move.y = transformed_point.y();
+    mouse_move.position.x = transformed_point.x();
+    mouse_move.position.y = transformed_point.y();
     common_ancestor->ProcessMouseEvent(mouse_move, ui::LatencyInfo());
   }
 
   // Send MouseMoves to trigger MouseEnter handlers.
   for (auto* view : entered_views) {
     if (view == target)
       continue;
     blink::WebMouseEvent mouse_enter(*event);
     mouse_enter.setType(blink::WebInputEvent::MouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
-            gfx::Point(event->x, event->y), view, &transformed_point))
+            gfx::Point(event->position.x, event->position.y), view,
+            &transformed_point))
       transformed_point = gfx::Point();
-    mouse_enter.x = transformed_point.x();
-    mouse_enter.y = transformed_point.y();
+    mouse_enter.position.x = transformed_point.x();
+    mouse_enter.position.y = transformed_point.y();
     view->ProcessMouseEvent(mouse_enter, ui::LatencyInfo());
   }
 
   last_mouse_move_target_ = target;
   last_mouse_move_root_view_ = root_view;
 }
 
 void RenderWidgetHostInputEventRouter::BubbleScrollEvent(
     RenderWidgetHostViewBase* target_view,
     const blink::WebGestureEvent& event) {
@@ skipping 271 matching lines @@
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content