Clean up some remaining obsolete coordinate-space naming.

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 48 matching lines @@
             scale = rootView->inputEventsScaleFactor();
     }
     return delta / scale;
 }
 
 static FloatSize scaleSizeToWindow(const Widget* widget, FloatSize size)
 {
     return FloatSize(scaleDeltaToWindow(widget, size.width()), scaleDeltaToWindow(widget, size.height()));
 }
 
-static FloatPoint convertHitPointToWindow(const Widget* widget, FloatPoint point)
+// This method converts from the renderer's coordinate space into Blink's root frame coordinate space.
+// It's somewhat unique in that it takes into account DevTools emulation, which applies a scale and offset
+// in the root layer (see updateRootLayerTransform in WebViewImpl) as well as the overscroll effect on OSX.
+// This is in addition to the visual viewport "pinch-zoom" transformation and is one of the few cases where
+// the visual viewport is not equal to the renderer's coordinate-space.
+static FloatPoint convertHitPointToRootFrame(const Widget* widget, FloatPoint pointInRendererViewport)
 {
     float scale = 1;
     IntSize offset;
     IntPoint visualViewport;
     FloatSize overscrollOffset;
     if (widget) {
         FrameView* rootView = toFrameView(widget->root());
         if (rootView) {
             scale = rootView->inputEventsScaleFactor();
             offset = rootView->inputEventsOffsetForEmulation();
             visualViewport = flooredIntPoint(rootView->page()->frameHost().visualViewport().visibleRect().location());
             overscrollOffset = rootView->page()->frameHost().chromeClient().elasticOverscroll();
         }
     }
     return FloatPoint(
-        (point.x() - offset.width()) / scale + visualViewport.x() + overscrollOffset.width(),
-        (point.y() - offset.height()) / scale + visualViewport.y() + overscrollOffset.height());
+        (pointInRendererViewport.x() - offset.width()) / scale + visualViewport.x() + overscrollOffset.width(),
+        (pointInRendererViewport.y() - offset.height()) / scale + visualViewport.y() + overscrollOffset.height());
 }
 
 static unsigned toPlatformModifierFrom(WebMouseEvent::Button button)
 {
     if (button == WebMouseEvent::ButtonNone)
         return 0;
 
     unsigned webMouseButtonToPlatformModifier[] = {
         PlatformEvent::LeftButtonDown,
         PlatformEvent::MiddleButtonDown,
         PlatformEvent::RightButtonDown
     };
 
     return webMouseButtonToPlatformModifier[button];
 }
 
 // MakePlatformMouseEvent -----------------------------------------------------
 
 // TODO(mustaq): Add tests for this.
 PlatformMouseEventBuilder::PlatformMouseEventBuilder(Widget* widget, const WebMouseEvent& e)
 {
     // FIXME: Widget is always toplevel, unless it's a popup. We may be able
     // to get rid of this once we abstract popups into a WebKit API.
-    m_position = widget->convertFromContainingWindow(flooredIntPoint(convertHitPointToWindow(widget, IntPoint(e.x, e.y))));
+    m_position = widget->convertFromRootFrame(flooredIntPoint(convertHitPointToRootFrame(widget, IntPoint(e.x, e.y))));
     m_globalPosition = IntPoint(e.globalX, e.globalY);
     m_movementDelta = IntPoint(scaleDeltaToWindow(widget, e.movementX), scaleDeltaToWindow(widget, e.movementY));
     m_button = static_cast<MouseButton>(e.button);
     m_modifiers = e.modifiers;
 
     m_timestamp = e.timeStampSeconds;
     m_clickCount = e.clickCount;
 
     m_pointerProperties = static_cast<WebPointerProperties>(e);
 
@@ skipping 19 matching lines @@
 
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 // PlatformWheelEventBuilder --------------------------------------------------
 
 PlatformWheelEventBuilder::PlatformWheelEventBuilder(Widget* widget, const WebMouseWheelEvent& e)
 {
-    m_position = widget->convertFromContainingWindow(flooredIntPoint(convertHitPointToWindow(widget, FloatPoint(e.x, e.y))));
+    m_position = widget->convertFromRootFrame(flooredIntPoint(convertHitPointToRootFrame(widget, FloatPoint(e.x, e.y))));
     m_globalPosition = IntPoint(e.globalX, e.globalY);
     m_deltaX = e.deltaX;
     m_deltaY = e.deltaY;
     m_wheelTicksX = e.wheelTicksX;
     m_wheelTicksY = e.wheelTicksY;
     m_granularity = e.scrollByPage ?
         ScrollByPageWheelEvent : ScrollByPixelWheelEvent;
 
     m_type = PlatformEvent::Wheel;
 
@@ skipping 85 matching lines @@
     case WebInputEvent::GesturePinchEnd:
         m_type = PlatformEvent::GesturePinchEnd;
         break;
     case WebInputEvent::GesturePinchUpdate:
         m_type = PlatformEvent::GesturePinchUpdate;
         m_data.m_pinchUpdate.m_scale = e.data.pinchUpdate.scale;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
-    m_position = widget->convertFromContainingWindow(flooredIntPoint(convertHitPointToWindow(widget, FloatPoint(e.x, e.y))));
+    m_position = widget->convertFromRootFrame(flooredIntPoint(convertHitPointToRootFrame(widget, FloatPoint(e.x, e.y))));
     m_globalPosition = IntPoint(e.globalX, e.globalY);
     m_timestamp = e.timeStampSeconds;
     m_modifiers = e.modifiers;
     switch (e.sourceDevice) {
     case WebGestureDeviceTouchpad:
         m_source = PlatformGestureSourceTouchpad;
         break;
     case WebGestureDeviceTouchscreen:
         m_source = PlatformGestureSourceTouchscreen;
         break;
@@ skipping 117 matching lines @@
         return WebTouchPoint::StateMoved;
     return WebTouchPoint::StateUndefined;
 }
 
 // TODO(mustaq): Add tests for this.
 PlatformTouchPointBuilder::PlatformTouchPointBuilder(Widget* widget, const WebTouchPoint& point)
 {
     m_pointerProperties = point;
     m_state = toPlatformTouchPointState(point.state);
 
-    // This assumes convertFromContainingWindow does only translations, not scales.
-    FloatPoint floatPos = convertHitPointToWindow(widget, point.position);
+    // This assumes convertFromRootFrame does only translations, not scales.
+    FloatPoint floatPos = convertHitPointToRootFrame(widget, point.position);
     IntPoint flooredPoint = flooredIntPoint(floatPos);
-    m_pos = widget->convertFromContainingWindow(flooredPoint) + (floatPos - flooredPoint);
+    m_pos = widget->convertFromRootFrame(flooredPoint) + (floatPos - flooredPoint);
 
     m_screenPos = FloatPoint(point.screenPosition.x, point.screenPosition.y);
     m_radius = scaleSizeToWindow(widget, FloatSize(point.radiusX, point.radiusY));
     m_rotationAngle = point.rotationAngle;
 }
 
 PlatformTouchEventBuilder::PlatformTouchEventBuilder(Widget* widget, const WebTouchEvent& event)
 {
     m_type = toPlatformTouchEventType(event.type);
     m_modifiers = event.modifiers;
@@ skipping 17 matching lines @@
 }
 
 // FIXME: Change |widget| to const Widget& after RemoteFrames get
 // RemoteFrameViews.
 static void updateWebMouseEventFromCoreMouseEvent(const MouseRelatedEvent& event, const Widget* widget, const LayoutObject& layoutObject, WebMouseEvent& webEvent)
 {
     webEvent.timeStampSeconds = convertDOMTimeStampToSeconds(event.createTime());
     webEvent.modifiers = event.modifiers();
 
     FrameView* view = widget ? toFrameView(widget->parent()) : 0;
-    // FIXME: If view == nullptr, pointInRootFrame will really be pointInRootContent.
+    // TODO(bokan): If view == nullptr, pointInRootFrame will really be pointInRootContent.
     IntPoint pointInRootFrame = IntPoint(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 = convertAbsoluteLocationForLayoutObject(event.absoluteLocation(), layoutObject);
     webEvent.x = localPoint.x();
     webEvent.y = localPoint.y();
@@ skipping 279 matching lines @@
         break;
     case GestureSourceTouchscreen:
         sourceDevice = WebGestureDeviceTouchscreen;
         break;
     case GestureSourceUninitialized:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink