Making EventSender talk to the right WebWidget (for OOPIF support).

ui/events/blink/blink_event_util.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
+#include "ui/gfx/geometry/vector2d.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebPointerProperties;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace ui {
 namespace {
 
@@ skipping 320 matching lines @@
     const GestureEventData& data) {
   return CreateWebGestureEvent(data.details, data.time,
                                gfx::PointF(data.x, data.y),
                                gfx::PointF(data.raw_x, data.raw_y), data.flags,
                                data.unique_touch_event_id);
 }
 
 std::unique_ptr<blink::WebInputEvent> ScaleWebInputEvent(
     const blink::WebInputEvent& event,
     float scale) {
+  return TranslateAndScaleWebInputEvent(event, gfx::Vector2d(0, 0), scale);
+}
+
+std::unique_ptr<blink::WebInputEvent> TranslateAndScaleWebInputEvent(
+    const blink::WebInputEvent& event,
+    const gfx::Vector2d& delta,
+    float scale) {
   std::unique_ptr<blink::WebInputEvent> scaled_event;
-  if (scale == 1.f)
+  if (scale == 1.f && delta.IsZero())
     return scaled_event;
   if (event.type == blink::WebMouseEvent::MouseWheel) {
     blink::WebMouseWheelEvent* wheel_event = new blink::WebMouseWheelEvent;
     scaled_event.reset(wheel_event);
     *wheel_event = static_cast<const blink::WebMouseWheelEvent&>(event);
+    wheel_event->x += delta.x();
+    wheel_event->y += delta.y();
     wheel_event->x *= scale;
     wheel_event->y *= scale;
     wheel_event->deltaX *= scale;
     wheel_event->deltaY *= scale;
     wheel_event->wheelTicksX *= scale;
     wheel_event->wheelTicksY *= scale;
   } else if (blink::WebInputEvent::isMouseEventType(event.type)) {
     blink::WebMouseEvent* mouse_event = new blink::WebMouseEvent;
     scaled_event.reset(mouse_event);
     *mouse_event = static_cast<const blink::WebMouseEvent&>(event);
+    mouse_event->x += delta.x();
+    mouse_event->y += delta.y();
     mouse_event->x *= scale;
     mouse_event->y *= scale;
     mouse_event->windowX = mouse_event->x;
     mouse_event->windowY = mouse_event->y;
     mouse_event->movementX *= scale;
     mouse_event->movementY *= scale;
   } else if (blink::WebInputEvent::isTouchEventType(event.type)) {
     blink::WebTouchEvent* touch_event = new blink::WebTouchEvent;
     scaled_event.reset(touch_event);
     *touch_event = static_cast<const blink::WebTouchEvent&>(event);
     for (unsigned i = 0; i < touch_event->touchesLength; i++) {
+      touch_event->touches[i].position.x += delta.x();
+      touch_event->touches[i].position.y += delta.y();
       touch_event->touches[i].position.x *= scale;
       touch_event->touches[i].position.y *= scale;
       touch_event->touches[i].radiusX *= scale;
       touch_event->touches[i].radiusY *= scale;
     }
   } else if (blink::WebInputEvent::isGestureEventType(event.type)) {
     blink::WebGestureEvent* gesture_event = new blink::WebGestureEvent;
     scaled_event.reset(gesture_event);
     *gesture_event = static_cast<const blink::WebGestureEvent&>(event);
+    gesture_event->x += delta.x();
+    gesture_event->y += delta.y();
     gesture_event->x *= scale;
     gesture_event->y *= scale;
     switch (gesture_event->type) {
       case blink::WebInputEvent::GestureScrollUpdate:
         gesture_event->data.scrollUpdate.deltaX *= scale;
         gesture_event->data.scrollUpdate.deltaY *= scale;
         break;
       case blink::WebInputEvent::GestureScrollBegin:
         gesture_event->data.scrollBegin.deltaXHint *= scale;
         gesture_event->data.scrollBegin.deltaYHint *= scale;
@@ skipping 107 matching lines @@
       return blink::WebInputEvent::IsRight;
     case DomKeyLocation::NUMPAD:
       return blink::WebInputEvent::IsKeyPad;
     case DomKeyLocation::STANDARD:
       break;
   }
   return static_cast<blink::WebInputEvent::Modifiers>(0);
 }
 
 }  // namespace ui