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

components/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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/test_runner/mock_spell_check.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/test_runner/web_view_test_proxy.h"
+#include "components/test_runner/web_widget_test_proxy.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
+#include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebPointerProperties.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
@@ skipping 1237 matching lines @@
 
 WebMouseEvent::Button EventSender::last_button_type_ =
     WebMouseEvent::Button::NoButton;
 
 EventSender::SavedEvent::SavedEvent()
     : type(TYPE_UNSPECIFIED),
       button_type(WebMouseEvent::Button::NoButton),
       milliseconds(0),
       modifiers(0) {}
 
-EventSender::EventSender(WebViewTestProxyBase* web_view_test_proxy_base)
-    : web_view_test_proxy_base_(web_view_test_proxy_base),
+EventSender::EventSender(WebWidgetTestProxyBase* web_widget_test_proxy_base)
+    : web_widget_test_proxy_base_(web_widget_test_proxy_base),
       replaying_saved_events_(false),
       weak_factory_(this) {
   Reset();
 }
 
 EventSender::~EventSender() {}
 
 void EventSender::Reset() {
   DCHECK(current_drag_data_.isNull());
   current_drag_data_.reset();
   current_drag_effect_ = blink::WebDragOperationNone;
   current_drag_effects_allowed_ = blink::WebDragOperationNone;
-  if (view() &&
+  if (widget() &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ !=
           WebMouseEvent::Button::NoButton)
-    view()->mouseCaptureLost();
+    widget()->mouseCaptureLost();
   current_pointer_state_.clear();
   is_drag_mode_ = true;
   force_layout_on_events_ = true;
 
 #if defined(OS_WIN)
   wm_key_down_ = WM_KEYDOWN;
   wm_key_up_ = WM_KEYUP;
   wm_char_ = WM_CHAR;
   wm_dead_char_ = WM_DEADCHAR;
   wm_sys_key_down_ = WM_SYSKEYDOWN;
@@ skipping 22 matching lines @@
 void EventSender::Install(WebLocalFrame* frame) {
   EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame);
 }
 
 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
-  WebMouseEvent unscaled_event;
+  WebMouseEvent raw_event;
   InitMouseEvent(WebInputEvent::MouseDown,
                  current_pointer_state_[kRawMousePointerId].pressed_button_,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_,
                  current_pointer_state_[kRawMousePointerId].modifiers_,
-                 &unscaled_event);
+                 &raw_event);
 
-  std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
+  std::unique_ptr<WebInputEvent> widget_event =
+      TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
-      scaled_event.get() ? static_cast<WebMouseEvent*>(scaled_event.get())
-                         : &unscaled_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);
   current_drag_data_ = drag_data;
   current_drag_effects_allowed_ = mask;
   current_drag_effect_ = view()->dragTargetDragEnter(
       drag_data, client_point, screen_point, current_drag_effects_allowed_,
       modifiersWithButtons(
           current_pointer_state_[kRawMousePointerId].modifiers_,
           current_pointer_state_[kRawMousePointerId].current_buttons_));
@@ skipping 14 matching lines @@
 }
 
 void EventSender::PointerDown(int button_number,
                               int modifiers,
                               WebPointerProperties::PointerType pointerType,
                               int pointerId,
                               float pressure,
                               int tiltX,
                               int tiltY) {
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   WebMouseEvent event;
   int click_count = 0;
   current_pointer_state_[pointerId].pressed_button_ = button_type;
   current_pointer_state_[pointerId].current_buttons_ |=
@@ skipping 16 matching lines @@
 }
 
 void EventSender::PointerUp(int button_number,
                             int modifiers,
                             WebPointerProperties::PointerType pointerType,
                             int pointerId,
                             float pressure,
                             int tiltX,
                             int tiltY) {
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   if (pointerType == WebPointerProperties::PointerType::Mouse &&
       is_drag_mode_ && !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_UP;
@@ skipping 248 matching lines @@
     event_down.modifiers |= WebInputEvent::IsKeyPad;
     break;
   }
 
   WebKeyboardEvent event_up;
   event_up = event_down;
   event_up.type = WebInputEvent::KeyUp;
   // EventSender.m forces a layout here, with at least one
   // test (fast/forms/focus-control-to-page.html) relying on this.
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   // In the browser, if a keyboard event corresponds to an editor command,
   // the command will be dispatched to the renderer just before dispatching
   // the keyboard event, and then it will be executed in the
   // RenderView::handleCurrentKeyboardEvent() method.
   // We just simulate the same behavior here.
   std::string edit_command;
   if (GetEditCommand(event_down, &edit_command))
     delegate()->SetEditCommand(edit_command, "");
 
@@ skipping 20 matching lines @@
   HandleInputEventOnViewOrPopup(event_up);
 }
 
 void EventSender::EnableDOMUIEventLogging() {}
 
 void EventSender::FireKeyboardEventsToElement() {}
 
 void EventSender::ClearKillRing() {}
 
 std::vector<std::string> EventSender::ContextClick() {
-  if (force_layout_on_events_) {
-    view()->updateAllLifecyclePhases();
-  }
+  if (force_layout_on_events_)
+    widget()->updateAllLifecyclePhases();
 
   UpdateClickCountForButton(WebMouseEvent::Button::Right);
 
   // Clears last context menu data because we need to know if the context menu
   // be requested after following mouse events.
   last_context_menu_data_.reset();
 
   // Generate right mouse down and up.
   WebMouseEvent event;
   // This is a hack to work around only allowing a single pressed button since
@@ skipping 153 matching lines @@
 void EventSender::GestureFlingCancel() {
   WebGestureEvent event;
   event.type = WebInputEvent::GestureFlingCancel;
   // Generally it won't matter what device we use here, and since it might
   // be cumbersome to expect all callers to specify a device, we'll just
   // choose Touchpad here.
   event.sourceDevice = blink::WebGestureDeviceTouchpad;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::GestureFlingStart(float x,
                                     float y,
                                     float velocity_x,
                                     float velocity_y,
                                     gin::Arguments* args) {
   WebGestureEvent event;
@@ skipping 23 matching lines @@
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 bool EventSender::IsFlinging() const {
   return view()->isFlinging();
 }
 
 void EventSender::GestureScrollFirstPoint(int x, int y) {
   current_gesture_location_ = WebPoint(x, y);
@@ skipping 166 matching lines @@
   InitMouseWheelEvent(args, scroll_type, &wheel_event, &send_gestures);
   if (HandleInputEventOnViewOrPopup(wheel_event) ==
           WebInputEventResult::NotHandled &&
       send_gestures) {
     SendGesturesForMouseWheelEvent(wheel_event);
   }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   double x;
   double y;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
     return;
   }
   WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y));
 
   int modifiers = 0;
@@ skipping 34 matching lines @@
         GetCurrentEventTimeSec(), click_count, modifiers, pointerType,
         pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::Button::NoButton, 0,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
@@ skipping 48 matching lines @@
 
 void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
                                         gin::Arguments* args) {
   bool moved_beyond_slop_region;
   uint32_t unique_touch_event_id;
   GetOptionalTouchArgs(args, moved_beyond_slop_region, unique_touch_event_id);
 
   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap),
             touch_points_.size());
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   WebTouchEvent touch_event;
   touch_event.type = type;
   touch_event.modifiers = touch_modifiers_;
   touch_event.dispatchType = touch_cancelable_
                                  ? WebInputEvent::Blocking
                                  : WebInputEvent::EventNonBlocking;
   touch_event.timeStampSeconds = GetCurrentEventTimeSec();
   touch_event.movedBeyondSlopRegion = moved_beyond_slop_region;
   touch_event.uniqueTouchEventId = unique_touch_event_id;
@@ skipping 238 matching lines @@
       NOTREACHED();
   }
 
   event.uniqueTouchEventId = GetUniqueTouchEventId(args);
 
   event.globalX = event.x;
   event.globalY = event.y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   WebInputEventResult result = HandleInputEventOnViewOrPopup(event);
 
   // Long press might start a drag drop session. Complete it if so.
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    current_pointer_state_[kRawMousePointerId].pressed_button_,
                    current_pointer_state_[kRawMousePointerId].current_buttons_,
                    WebPoint(x, y), GetCurrentEventTimeSec(), click_count_,
@@ skipping 21 matching lines @@
 }
 
 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
                                       MouseScrollType scroll_type,
                                       WebMouseWheelEvent* event,
                                       bool* send_gestures) {
   // Force a layout here just to make sure every position has been
   // determined before we send events (as well as all the other methods
   // that send an event do).
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   double horizontal;
   if (!args->GetNext(&horizontal)) {
     args->ThrowError();
     return;
   }
   double vertical;
   if (!args->GetNext(&vertical)) {
     args->ThrowError();
     return;
@@ skipping 86 matching lines @@
       return;
     }
     e->tiltX = tiltX;
     e->tiltY = tiltY;
   }
 
   if (!getPointerType(args, false, e->pointerType))
     return;
 }
 
-void EventSender::FinishDragAndDrop(const WebMouseEvent& unscaled_event,
+void EventSender::FinishDragAndDrop(const WebMouseEvent& raw_event,
                                     blink::WebDragOperation drag_effect) {
-  std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
+  std::unique_ptr<WebInputEvent> widget_event =
+      TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
-      scaled_event.get() ? static_cast<const WebMouseEvent*>(scaled_event.get())
-                         : &unscaled_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);
   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).
     view()->dragTargetDrop(current_drag_data_, client_point, screen_point,
                            event->modifiers);
   } else {
     view()->dragTargetDragLeave();
   }
   current_drag_data_.reset();
   view()->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
   view()->dragSourceSystemDragEnded();
 }
 
-void EventSender::DoDragAfterMouseUp(const WebMouseEvent& unscaled_event) {
-  std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
+void EventSender::DoDragAfterMouseUp(const WebMouseEvent& raw_event) {
+  std::unique_ptr<WebInputEvent> widget_event =
+      TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
-      scaled_event.get() ? static_cast<WebMouseEvent*>(scaled_event.get())
-                         : &unscaled_event;
+      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);
   blink::WebDragOperation drag_effect = view()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
       event->modifiers);
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
-  FinishDragAndDrop(unscaled_event, drag_effect);
+  FinishDragAndDrop(raw_event, drag_effect);
 }
 
-void EventSender::DoDragAfterMouseMove(const WebMouseEvent& unscaled_event) {
+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> scaled_event = ScaleEvent(unscaled_event);
+  std::unique_ptr<WebInputEvent> widget_event =
+      TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
-      scaled_event.get() ? static_cast<WebMouseEvent*>(scaled_event.get())
-                         : &unscaled_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);
   current_drag_effect_ = view()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
       event->modifiers);
 }
 
 void EventSender::ReplaySavedEvents() {
   replaying_saved_events_ = true;
@@ skipping 36 matching lines @@
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
 }
 
 WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
-    const WebInputEvent& unscaled_event) {
-  std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
+    const WebInputEvent& raw_event) {
+  last_event_timestamp_ = raw_event.timeStampSeconds;
+
+  WebPagePopup* popup = widget()->pagePopup();
+  if (popup && !WebInputEvent::isKeyboardEventType(raw_event.type)) {
+    // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the
+    // event does not have to be converted.
+    std::unique_ptr<WebInputEvent> scaled_event = ui::ScaleWebInputEvent(
+        raw_event, delegate()->GetWindowToViewportScale());
+    const WebInputEvent* popup_friendly_event =
+        scaled_event.get() ? scaled_event.get() : &raw_event;
+    return popup->handleInputEvent(*popup_friendly_event);
+  }
+
+  std::unique_ptr<WebInputEvent> widget_event =
+      TransformScreenToWidgetCoordinates(raw_event);
   const WebInputEvent* event =
-      scaled_event.get() ? scaled_event.get() : &unscaled_event;
-
-  last_event_timestamp_ = event->timeStampSeconds;
-
-  if (WebPagePopup* popup = view()->pagePopup()) {
-    if (!WebInputEvent::isKeyboardEventType(event->type))
-      return popup->handleInputEvent(*event);
-  }
-  return view()->handleInputEvent(*event);
+      widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
+                         : &raw_event;
+  return widget()->handleInputEvent(*event);
 }
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
   WebGestureEvent begin_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollBegin,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &begin_event);
   begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
   begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
   if (wheel_event.scrollByPage) {
     begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page;
     if (begin_event.data.scrollBegin.deltaXHint) {
       begin_event.data.scrollBegin.deltaXHint =
           begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
     }
     if (begin_event.data.scrollBegin.deltaYHint) {
       begin_event.data.scrollBegin.deltaYHint =
           begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
     }
   } else {
     begin_event.data.scrollBegin.deltaHintUnits =
         wheel_event.hasPreciseScrollingDeltas
             ? blink::WebGestureEvent::PrecisePixels
             : blink::WebGestureEvent::Pixels;
   }
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(begin_event);
 
   WebGestureEvent update_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollUpdate,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &update_event);
   update_event.data.scrollUpdate.deltaX =
       begin_event.data.scrollBegin.deltaXHint;
   update_event.data.scrollUpdate.deltaY =
       begin_event.data.scrollBegin.deltaYHint;
   update_event.data.scrollUpdate.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(update_event);
 
   WebGestureEvent end_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollEnd,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
-    view()->updateAllLifecyclePhases();
+    widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
 TestInterfaces* EventSender::interfaces() {
-  return web_view_test_proxy_base_->test_interfaces();
+  return web_widget_test_proxy_base_->web_view_test_proxy_base()
+      ->test_interfaces();
 }
 
 WebTestDelegate* EventSender::delegate() {
-  return web_view_test_proxy_base_->delegate();
+  return web_widget_test_proxy_base_->web_view_test_proxy_base()->delegate();
 }
 
 const blink::WebView* EventSender::view() const {
-  return web_view_test_proxy_base_->web_view();
+  return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view();
 }
 
 blink::WebView* EventSender::view() {
-  return web_view_test_proxy_base_->web_view();
+  return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view();
 }
 
-std::unique_ptr<WebInputEvent> EventSender::ScaleEvent(
+blink::WebWidget* EventSender::widget() {
+  return web_widget_test_proxy_base_->web_widget();
+}
+
+std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates(
     const WebInputEvent& event) {
-  // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the event
-  // does not have to be converted.
-  return ui::ScaleWebInputEvent(event, delegate()->GetWindowToViewportScale());
+  return delegate()->TransformScreenToWidgetCoordinates(
+      web_widget_test_proxy_base_, event);
 }
 
 }  // namespace test_runner