Rename platform/Widget to platform/FrameViewBase in web.

third_party/WebKit/Source/web/WebInputEventConversion.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/VisualViewport.h"
 #include "core/layout/api/LayoutItem.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
+#include "platform/FrameViewBase.h"
 #include "platform/KeyboardCodes.h"
-#include "platform/Widget.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 namespace {
-float frameScale(const Widget* widget) {
+float frameScale(const FrameViewBase* frameViewBase) {
   float scale = 1;
-  if (widget) {
-    FrameView* rootView = toFrameView(widget->root());
+  if (frameViewBase) {
+    FrameView* rootView = toFrameView(frameViewBase->root());
     if (rootView)
       scale = rootView->inputEventsScaleFactor();
   }
   return scale;
 }
 
-FloatPoint frameTranslation(const Widget* widget) {
+FloatPoint frameTranslation(const FrameViewBase* frameViewBase) {
   float scale = 1;
   FloatSize offset;
   IntPoint visualViewport;
   FloatSize overscrollOffset;
-  if (widget) {
-    FrameView* rootView = toFrameView(widget->root());
+  if (frameViewBase) {
+    FrameView* rootView = toFrameView(frameViewBase->root());
     if (rootView) {
       scale = rootView->inputEventsScaleFactor();
       offset = FloatSize(rootView->inputEventsOffsetForEmulation());
       visualViewport = flooredIntPoint(rootView->page()
                                            ->frameHost()
                                            .visualViewport()
                                            .visibleRect()
                                            .location());
       overscrollOffset = rootView->page()->chromeClient().elasticOverscroll();
     }
@@ skipping 10 matching lines @@
   return layoutItem.absoluteToLocal(FloatPoint(location), UseTransforms);
 }
 
 IntPoint convertAbsoluteLocationForLayoutObjectInt(
     const DoublePoint& location,
     const LayoutItem layoutItem) {
   return roundedIntPoint(
       convertAbsoluteLocationForLayoutObjectFloat(location, layoutItem));
 }
 
-// FIXME: Change |widget| to const Widget& after RemoteFrames get
+// FIXME: Change |FrameViewBase| to const FrameViewBase& after RemoteFrames get
 // RemoteFrameViews.
 void updateWebMouseEventFromCoreMouseEvent(const MouseEvent& event,
-                                           const Widget* widget,
+                                           const FrameViewBase* frameViewBase,
                                            const LayoutItem layoutItem,
                                            WebMouseEvent& webEvent) {
   webEvent.setTimeStampSeconds(event.platformTimeStamp().InSeconds());
   webEvent.setModifiers(event.modifiers());
 
-  FrameView* view = widget ? toFrameView(widget->parent()) : 0;
+  FrameView* view = frameViewBase ? toFrameView(frameViewBase->parent()) : 0;
   // TODO(bokan): If view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame(event.absoluteLocation().x(),
                             event.absoluteLocation().y());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
   webEvent.globalX = event.screenX();
   webEvent.globalY = event.screenY();
   webEvent.windowX = pointInRootFrame.x();
   webEvent.windowY = pointInRootFrame.y();
   IntPoint localPoint = convertAbsoluteLocationForLayoutObjectInt(
       event.absoluteLocation(), layoutItem);
   webEvent.x = localPoint.x();
   webEvent.y = localPoint.y();
 }
 
 unsigned toWebInputEventModifierFrom(WebMouseEvent::Button button) {
   if (button == WebMouseEvent::Button::NoButton)
     return 0;
 
   unsigned webMouseButtonToPlatformModifier[] = {
       WebInputEvent::LeftButtonDown, WebInputEvent::MiddleButtonDown,
       WebInputEvent::RightButtonDown};
 
   return webMouseButtonToPlatformModifier[static_cast<int>(button)];
 }
 
 }  // namespace
 
-WebMouseEvent TransformWebMouseEvent(Widget* widget,
+WebMouseEvent TransformWebMouseEvent(FrameViewBase* frameViewBase,
                                      const WebMouseEvent& event) {
   WebMouseEvent result = event;
 
   // TODO(dtapuska): Remove this translation. In the past blink has
   // converted leaves into moves and not known about leaves. It should
   // be educated about them. crbug.com/686196
   if (event.type() == WebInputEvent::MouseEnter ||
       event.type() == WebInputEvent::MouseLeave) {
     result.setType(WebInputEvent::MouseMove);
   }
 
   // TODO(dtapuska): Perhaps the event should be constructed correctly?
   // crbug.com/686200
   if (event.type() == WebInputEvent::MouseUp) {
     result.setModifiers(event.modifiers() &
                         ~toWebInputEventModifierFrom(event.button));
   }
-  result.setFrameScale(frameScale(widget));
-  result.setFrameTranslate(frameTranslation(widget));
+  result.setFrameScale(frameScale(frameViewBase));
+  result.setFrameTranslate(frameTranslation(frameViewBase));
   return result;
 }
 
 WebMouseWheelEvent TransformWebMouseWheelEvent(
-    Widget* widget,
+    FrameViewBase* frameViewBase,
     const WebMouseWheelEvent& event) {
   WebMouseWheelEvent result = event;
-  result.setFrameScale(frameScale(widget));
-  result.setFrameTranslate(frameTranslation(widget));
+  result.setFrameScale(frameScale(frameViewBase));
+  result.setFrameTranslate(frameTranslation(frameViewBase));
   return result;
 }
 
-WebGestureEvent TransformWebGestureEvent(Widget* widget,
+WebGestureEvent TransformWebGestureEvent(FrameViewBase* frameViewBase,
                                          const WebGestureEvent& event) {
   WebGestureEvent result = event;
-  result.setFrameScale(frameScale(widget));
-  result.setFrameTranslate(frameTranslation(widget));
+  result.setFrameScale(frameScale(frameViewBase));
+  result.setFrameTranslate(frameTranslation(frameViewBase));
   return result;
 }
 
 WebTouchEvent TransformWebTouchEvent(float frameScale,
                                      FloatPoint frameTranslate,
                                      const WebTouchEvent& event) {
   // frameScale is default initialized in debug builds to be 0.
   DCHECK_EQ(0, event.frameScale());
   DCHECK_EQ(0, event.frameTranslate().x);
   DCHECK_EQ(0, event.frameTranslate().y);
   WebTouchEvent result = event;
   result.setFrameScale(frameScale);
   result.setFrameTranslate(frameTranslate);
   return result;
 }
 
-WebTouchEvent TransformWebTouchEvent(Widget* widget,
+WebTouchEvent TransformWebTouchEvent(FrameViewBase* frameViewBase,
                                      const WebTouchEvent& event) {
-  return TransformWebTouchEvent(frameScale(widget), frameTranslation(widget),
-                                event);
+  return TransformWebTouchEvent(frameScale(frameViewBase),
+                                frameTranslation(frameViewBase), event);
 }
 
-WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget,
+WebMouseEventBuilder::WebMouseEventBuilder(const FrameViewBase* frameViewBase,
                                            const LayoutItem layoutItem,
                                            const MouseEvent& event) {
   if (event.nativeEvent()) {
     *static_cast<WebMouseEvent*>(this) =
         event.nativeEvent()->flattenTransform();
     WebFloatPoint absoluteRootFrameLocation = positionInRootFrame();
     IntPoint localPoint = roundedIntPoint(
         layoutItem.absoluteToLocal(absoluteRootFrameLocation, UseTransforms));
     x = localPoint.x();
     y = localPoint.y();
@@ skipping 14 matching lines @@
     m_type = WebInputEvent::MouseDown;
   else if (event.type() == EventTypeNames::mouseup)
     m_type = WebInputEvent::MouseUp;
   else if (event.type() == EventTypeNames::contextmenu)
     m_type = WebInputEvent::ContextMenu;
   else
     return;  // Skip all other mouse events.
 
   m_timeStampSeconds = event.platformTimeStamp().InSeconds();
   m_modifiers = event.modifiers();
-  updateWebMouseEventFromCoreMouseEvent(event, widget, layoutItem, *this);
+  updateWebMouseEventFromCoreMouseEvent(event, frameViewBase, layoutItem,
+                                        *this);
 
   switch (event.button()) {
     case short(WebPointerProperties::Button::Left):
       button = WebMouseEvent::Button::Left;
       break;
     case short(WebPointerProperties::Button::Middle):
       button = WebMouseEvent::Button::Middle;
       break;
     case short(WebPointerProperties::Button::Right):
       button = WebMouseEvent::Button::Right;
@@ skipping 16 matching lines @@
   }
   movementX = event.movementX();
   movementY = event.movementY();
   clickCount = event.detail();
 
   pointerType = WebPointerProperties::PointerType::Mouse;
 }
 
 // Generate a synthetic WebMouseEvent given a TouchEvent (eg. for emulating a
 // mouse with touch input for plugins that don't support touch input).
-WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget,
+WebMouseEventBuilder::WebMouseEventBuilder(const FrameViewBase* frameViewBase,
                                            const LayoutItem layoutItem,
                                            const TouchEvent& event) {
   if (!event.touches())
     return;
   if (event.touches()->length() != 1) {
     if (event.touches()->length() || event.type() != EventTypeNames::touchend ||
         !event.changedTouches() || event.changedTouches()->length() != 1)
       return;
   }
 
@@ skipping 12 matching lines @@
   else
     return;
 
   m_timeStampSeconds = event.platformTimeStamp().InSeconds();
   m_modifiers = event.modifiers();
   m_frameScale = 1;
   m_frameTranslate = WebFloatPoint();
 
   // The mouse event co-ordinates should be generated from the co-ordinates of
   // the touch point.
-  FrameView* view = toFrameView(widget->parent());
+  FrameView* view = toFrameView(frameViewBase->parent());
   // FIXME: if view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame = roundedIntPoint(touch->absoluteLocation());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
   IntPoint screenPoint = roundedIntPoint(touch->screenLocation());
   globalX = screenPoint.x();
   globalY = screenPoint.y();
   windowX = pointInRootFrame.x();
   windowY = pointInRootFrame.y();
@@ skipping 29 matching lines @@
     m_type = WebInputEvent::Char;
   else
     return;  // Skip all other keyboard events.
 
   m_modifiers = event.modifiers();
   m_timeStampSeconds = event.platformTimeStamp().InSeconds();
   windowsKeyCode = event.keyCode();
 }
 
 Vector<WebMouseEvent> TransformWebMouseEventVector(
-    Widget* widget,
+    FrameViewBase* frameViewBase,
     const std::vector<const WebInputEvent*>& coalescedEvents) {
   Vector<WebMouseEvent> result;
   for (const auto& event : coalescedEvents) {
     DCHECK(WebInputEvent::isMouseEventType(event->type()));
     result.push_back(TransformWebMouseEvent(
-        widget, static_cast<const WebMouseEvent&>(*event)));
+        frameViewBase, static_cast<const WebMouseEvent&>(*event)));
   }
   return result;
 }
 
 Vector<WebTouchEvent> TransformWebTouchEventVector(
-    Widget* widget,
+    FrameViewBase* frameViewBase,
     const std::vector<const WebInputEvent*>& coalescedEvents) {
-  float scale = frameScale(widget);
-  FloatPoint translation = frameTranslation(widget);
+  float scale = frameScale(frameViewBase);
+  FloatPoint translation = frameTranslation(frameViewBase);
   Vector<WebTouchEvent> result;
   for (const auto& event : coalescedEvents) {
     DCHECK(WebInputEvent::isTouchEventType(event->type()));
     result.push_back(TransformWebTouchEvent(
         scale, translation, static_cast<const WebTouchEvent&>(*event)));
   }
   return result;
 }
 
 }  // namespace blink