/*
 * Copyright (C) 2012 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
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "web/WebInputEventConversion.h"

#include "core/dom/Touch.h"
#include "core/dom/TouchList.h"
#include "core/events/GestureEvent.h"
#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/LocalFrame.h"
#include "core/frame/VisualViewport.h"
#include "core/layout/api/LayoutViewItem.h"
#include "core/page/Page.h"
#include "platform/geometry/IntSize.h"
#include "platform/testing/URLTestHelpers.h"
#include "public/web/WebFrame.h"
#include "public/web/WebSettings.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "web/WebLocalFrameImpl.h"
#include "web/WebViewImpl.h"
#include "web/tests/FrameTestHelpers.h"

namespace blink {

KeyboardEvent* createKeyboardEventWithLocation(
    KeyboardEvent::KeyLocationCode location) {
  KeyboardEventInit keyEventInit;
  keyEventInit.setBubbles(true);
  keyEventInit.setCancelable(true);
  keyEventInit.setLocation(location);
  return new KeyboardEvent("keydown", keyEventInit);
}

int getModifiersForKeyLocationCode(KeyboardEvent::KeyLocationCode location) {
  KeyboardEvent* event = createKeyboardEventWithLocation(location);
  WebKeyboardEventBuilder convertedEvent(*event);
  return convertedEvent.modifiers;
}

TEST(WebInputEventConversionTest, WebKeyboardEventBuilder) {
  // Test key location conversion.
  int modifiers =
      getModifiersForKeyLocationCode(KeyboardEvent::kDomKeyLocationStandard);
  EXPECT_FALSE(modifiers & WebInputEvent::IsKeyPad ||
               modifiers & WebInputEvent::IsLeft ||
               modifiers & WebInputEvent::IsRight);

  modifiers =
      getModifiersForKeyLocationCode(KeyboardEvent::kDomKeyLocationLeft);
  EXPECT_TRUE(modifiers & WebInputEvent::IsLeft);
  EXPECT_FALSE(modifiers & WebInputEvent::IsKeyPad ||
               modifiers & WebInputEvent::IsRight);

  modifiers =
      getModifiersForKeyLocationCode(KeyboardEvent::kDomKeyLocationRight);
  EXPECT_TRUE(modifiers & WebInputEvent::IsRight);
  EXPECT_FALSE(modifiers & WebInputEvent::IsKeyPad ||
               modifiers & WebInputEvent::IsLeft);

  modifiers =
      getModifiersForKeyLocationCode(KeyboardEvent::kDomKeyLocationNumpad);
  EXPECT_TRUE(modifiers & WebInputEvent::IsKeyPad);
  EXPECT_FALSE(modifiers & WebInputEvent::IsLeft ||
               modifiers & WebInputEvent::IsRight);
}

TEST(WebInputEventConversionTest, WebMouseEventBuilder) {
  TouchEvent* event = TouchEvent::create();
  WebMouseEventBuilder mouse(0, 0, *event);
  EXPECT_EQ(WebInputEvent::Undefined, mouse.type);
}

TEST(WebInputEventConversionTest, WebTouchEventBuilder) {
  const std::string baseURL("http://www.test0.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  Document* document =
      toLocalFrame(webViewImpl->page()->mainFrame())->document();
  LocalDOMWindow* domWindow = document->domWindow();
  LayoutViewItem documentLayoutView = document->layoutViewItem();

  WebTouchPoint p0, p1;
  p0.id = 1;
  p1.id = 2;
  p0.screenPosition = WebFloatPoint(100.f, 50.f);
  p1.screenPosition = WebFloatPoint(150.f, 25.f);
  p0.position = WebFloatPoint(10.f, 10.f);
  p1.position = WebFloatPoint(5.f, 5.f);
  p0.radiusX = p1.radiusY = 10.f;
  p0.radiusY = p1.radiusX = 5.f;
  p0.rotationAngle = p1.rotationAngle = 1.f;
  p0.force = p1.force = 25.f;

  Touch* touch0 = Touch::create(toLocalFrame(webViewImpl->page()->mainFrame()),
                                document, p0.id, p0.screenPosition, p0.position,
                                FloatSize(p0.radiusX, p0.radiusY),
                                p0.rotationAngle, p0.force, String());
  Touch* touch1 = Touch::create(toLocalFrame(webViewImpl->page()->mainFrame()),
                                document, p1.id, p1.screenPosition, p1.position,
                                FloatSize(p1.radiusX, p1.radiusY),
                                p1.rotationAngle, p1.force, String());

  // Test touchstart.
  {
    TouchList* touchList = TouchList::create();
    touchList->append(touch0);
    TouchEvent* touchEvent = TouchEvent::create(
        touchList, touchList, touchList, EventTypeNames::touchstart, domWindow,
        PlatformEvent::NoModifiers, false, false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(1u, webTouchBuilder.touchesLength);
    EXPECT_EQ(WebInputEvent::TouchStart, webTouchBuilder.type);
    EXPECT_EQ(WebTouchPoint::StatePressed, webTouchBuilder.touches[0].state);
    EXPECT_FLOAT_EQ(p0.screenPosition.x,
                    webTouchBuilder.touches[0].screenPosition.x);
    EXPECT_FLOAT_EQ(p0.screenPosition.y,
                    webTouchBuilder.touches[0].screenPosition.y);
    EXPECT_FLOAT_EQ(p0.position.x, webTouchBuilder.touches[0].position.x);
    EXPECT_FLOAT_EQ(p0.position.y, webTouchBuilder.touches[0].position.y);
    EXPECT_FLOAT_EQ(p0.radiusX, webTouchBuilder.touches[0].radiusX);
    EXPECT_FLOAT_EQ(p0.radiusY, webTouchBuilder.touches[0].radiusY);
    EXPECT_FLOAT_EQ(p0.rotationAngle, webTouchBuilder.touches[0].rotationAngle);
    EXPECT_FLOAT_EQ(p0.force, webTouchBuilder.touches[0].force);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }

  // Test cancelable touchstart.
  {
    TouchList* touchList = TouchList::create();
    touchList->append(touch0);
    TouchEvent* touchEvent = TouchEvent::create(
        touchList, touchList, touchList, EventTypeNames::touchstart, domWindow,
        PlatformEvent::NoModifiers, true, false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    EXPECT_EQ(WebInputEvent::Blocking, webTouchBuilder.dispatchType);
  }

  // Test touchmove.
  {
    TouchList* activeTouchList = TouchList::create();
    TouchList* movedTouchList = TouchList::create();
    activeTouchList->append(touch0);
    activeTouchList->append(touch1);
    movedTouchList->append(touch0);
    TouchEvent* touchEvent = TouchEvent::create(
        activeTouchList, activeTouchList, movedTouchList,
        EventTypeNames::touchmove, domWindow, PlatformEvent::NoModifiers, false,
        false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(2u, webTouchBuilder.touchesLength);
    EXPECT_EQ(WebInputEvent::TouchMove, webTouchBuilder.type);
    EXPECT_EQ(WebTouchPoint::StateMoved, webTouchBuilder.touches[0].state);
    EXPECT_EQ(WebTouchPoint::StateStationary, webTouchBuilder.touches[1].state);
    EXPECT_EQ(p0.id, webTouchBuilder.touches[0].id);
    EXPECT_EQ(p1.id, webTouchBuilder.touches[1].id);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }

  // Test touchmove, different point yields same ordering.
  {
    TouchList* activeTouchList = TouchList::create();
    TouchList* movedTouchList = TouchList::create();
    activeTouchList->append(touch0);
    activeTouchList->append(touch1);
    movedTouchList->append(touch1);
    TouchEvent* touchEvent = TouchEvent::create(
        activeTouchList, activeTouchList, movedTouchList,
        EventTypeNames::touchmove, domWindow, PlatformEvent::NoModifiers, false,
        false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(2u, webTouchBuilder.touchesLength);
    EXPECT_EQ(WebInputEvent::TouchMove, webTouchBuilder.type);
    EXPECT_EQ(WebTouchPoint::StateStationary, webTouchBuilder.touches[0].state);
    EXPECT_EQ(WebTouchPoint::StateMoved, webTouchBuilder.touches[1].state);
    EXPECT_EQ(p0.id, webTouchBuilder.touches[0].id);
    EXPECT_EQ(p1.id, webTouchBuilder.touches[1].id);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }

  // Test touchend.
  {
    TouchList* activeTouchList = TouchList::create();
    TouchList* releasedTouchList = TouchList::create();
    activeTouchList->append(touch0);
    releasedTouchList->append(touch1);
    TouchEvent* touchEvent = TouchEvent::create(
        activeTouchList, activeTouchList, releasedTouchList,
        EventTypeNames::touchend, domWindow, PlatformEvent::NoModifiers, false,
        false, false, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(2u, webTouchBuilder.touchesLength);
    EXPECT_EQ(WebInputEvent::TouchEnd, webTouchBuilder.type);
    EXPECT_EQ(WebTouchPoint::StateStationary, webTouchBuilder.touches[0].state);
    EXPECT_EQ(WebTouchPoint::StateReleased, webTouchBuilder.touches[1].state);
    EXPECT_EQ(p0.id, webTouchBuilder.touches[0].id);
    EXPECT_EQ(p1.id, webTouchBuilder.touches[1].id);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }

  // Test touchcancel.
  {
    TouchList* activeTouchList = TouchList::create();
    TouchList* cancelledTouchList = TouchList::create();
    cancelledTouchList->append(touch0);
    cancelledTouchList->append(touch1);
    TouchEvent* touchEvent = TouchEvent::create(
        activeTouchList, activeTouchList, cancelledTouchList,
        EventTypeNames::touchcancel, domWindow, PlatformEvent::NoModifiers,
        false, false, false, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(2u, webTouchBuilder.touchesLength);
    EXPECT_EQ(WebInputEvent::TouchCancel, webTouchBuilder.type);
    EXPECT_EQ(WebTouchPoint::StateCancelled, webTouchBuilder.touches[0].state);
    EXPECT_EQ(WebTouchPoint::StateCancelled, webTouchBuilder.touches[1].state);
    EXPECT_EQ(p0.id, webTouchBuilder.touches[0].id);
    EXPECT_EQ(p1.id, webTouchBuilder.touches[1].id);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }

  // Test max point limit.
  {
    TouchList* touchList = TouchList::create();
    TouchList* changedTouchList = TouchList::create();
    for (int i = 0; i <= static_cast<int>(WebTouchEvent::kTouchesLengthCap) * 2;
         ++i) {
      Touch* touch = Touch::create(
          toLocalFrame(webViewImpl->page()->mainFrame()), document, i,
          p0.screenPosition, p0.position, FloatSize(p0.radiusX, p0.radiusY),
          p0.rotationAngle, p0.force, String());
      touchList->append(touch);
      changedTouchList->append(touch);
    }
    TouchEvent* touchEvent = TouchEvent::create(
        touchList, touchList, touchList, EventTypeNames::touchstart, domWindow,
        PlatformEvent::NoModifiers, false, false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap),
              webTouchBuilder.touchesLength);
  }
}

TEST(WebInputEventConversionTest, InputEventsScaling) {
  const std::string baseURL("http://www.test1.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  webViewImpl->settings()->setViewportEnabled(true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  webViewImpl->setPageScaleFactor(2);

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();
  Document* document =
      toLocalFrame(webViewImpl->page()->mainFrame())->document();
  LocalDOMWindow* domWindow = document->domWindow();
  LayoutViewItem documentLayoutView = document->layoutViewItem();

  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 10;
    webMouseEvent.y = 10;
    webMouseEvent.windowX = 10;
    webMouseEvent.windowY = 10;
    webMouseEvent.globalX = 10;
    webMouseEvent.globalY = 10;
    webMouseEvent.movementX = 10;
    webMouseEvent.movementY = 10;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(5, platformMouseBuilder.position().x());
    EXPECT_EQ(5, platformMouseBuilder.position().y());
    EXPECT_EQ(10, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(10, platformMouseBuilder.globalPosition().y());
    EXPECT_EQ(5, platformMouseBuilder.movementDelta().x());
    EXPECT_EQ(5, platformMouseBuilder.movementDelta().y());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollUpdate;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.x = 10;
    webGestureEvent.y = 12;
    webGestureEvent.globalX = 20;
    webGestureEvent.globalY = 22;
    webGestureEvent.data.scrollUpdate.deltaX = 30;
    webGestureEvent.data.scrollUpdate.deltaY = 32;
    webGestureEvent.data.scrollUpdate.velocityX = 40;
    webGestureEvent.data.scrollUpdate.velocityY = 42;
    webGestureEvent.data.scrollUpdate.inertialPhase =
        WebGestureEvent::MomentumPhase;
    webGestureEvent.data.scrollUpdate.preventPropagation = true;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.position().x());
    EXPECT_EQ(6, platformGestureBuilder.position().y());
    EXPECT_EQ(20, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(22, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(15, platformGestureBuilder.deltaX());
    EXPECT_EQ(16, platformGestureBuilder.deltaY());
    // TODO: The velocity values may need to be scaled to page scale in
    // order to remain consist with delta values.
    EXPECT_EQ(40, platformGestureBuilder.velocityX());
    EXPECT_EQ(42, platformGestureBuilder.velocityY());
    EXPECT_EQ(ScrollInertialPhaseMomentum,
              platformGestureBuilder.inertialPhase());
    EXPECT_TRUE(platformGestureBuilder.preventPropagation());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollEnd;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.x = 10;
    webGestureEvent.y = 12;
    webGestureEvent.globalX = 20;
    webGestureEvent.globalY = 22;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.position().x());
    EXPECT_EQ(6, platformGestureBuilder.position().y());
    EXPECT_EQ(20, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(22, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(ScrollInertialPhaseUnknown,
              platformGestureBuilder.inertialPhase());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTap;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tap.width = 10;
    webGestureEvent.data.tap.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTapUnconfirmed;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tap.width = 10;
    webGestureEvent.data.tap.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTapDown;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tapDown.width = 10;
    webGestureEvent.data.tapDown.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureShowPress;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.showPress.width = 10;
    webGestureEvent.data.showPress.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureLongPress;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.longPress.width = 10;
    webGestureEvent.data.longPress.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTwoFingerTap;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.twoFingerTap.firstFingerWidth = 10;
    webGestureEvent.data.twoFingerTap.firstFingerHeight = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5, platformGestureBuilder.area().width());
    EXPECT_EQ(5, platformGestureBuilder.area().height());
  }

  {
    WebTouchEvent webTouchEvent;
    webTouchEvent.type = WebInputEvent::TouchMove;
    webTouchEvent.touchesLength = 1;
    webTouchEvent.touches[0].state = WebTouchPoint::StateMoved;
    webTouchEvent.touches[0].screenPosition.x = 10.6f;
    webTouchEvent.touches[0].screenPosition.y = 10.4f;
    webTouchEvent.touches[0].position.x = 10.6f;
    webTouchEvent.touches[0].position.y = 10.4f;
    webTouchEvent.touches[0].radiusX = 10.6f;
    webTouchEvent.touches[0].radiusY = 10.4f;

    EXPECT_FLOAT_EQ(10.6f, webTouchEvent.touches[0].screenPosition.x);
    EXPECT_FLOAT_EQ(10.4f, webTouchEvent.touches[0].screenPosition.y);
    EXPECT_FLOAT_EQ(10.6f, webTouchEvent.touches[0].position.x);
    EXPECT_FLOAT_EQ(10.4f, webTouchEvent.touches[0].position.y);
    EXPECT_FLOAT_EQ(10.6f, webTouchEvent.touches[0].radiusX);
    EXPECT_FLOAT_EQ(10.4f, webTouchEvent.touches[0].radiusY);

    PlatformTouchEventBuilder platformTouchBuilder(view, webTouchEvent);
    EXPECT_FLOAT_EQ(10.6f,
                    platformTouchBuilder.touchPoints()[0].screenPos().x());
    EXPECT_FLOAT_EQ(10.4f,
                    platformTouchBuilder.touchPoints()[0].screenPos().y());
    EXPECT_FLOAT_EQ(5.3f, platformTouchBuilder.touchPoints()[0].pos().x());
    EXPECT_FLOAT_EQ(5.2f, platformTouchBuilder.touchPoints()[0].pos().y());
    EXPECT_FLOAT_EQ(5.3f,
                    platformTouchBuilder.touchPoints()[0].radius().width());
    EXPECT_FLOAT_EQ(5.2f,
                    platformTouchBuilder.touchPoints()[0].radius().height());
  }

  // Reverse builders should *not* go back to physical pixels, as they are used
  // for plugins which expect CSS pixel coordinates.
  {
    PlatformMouseEvent platformMouseEvent(
        IntPoint(10, 10), IntPoint(10, 10), WebPointerProperties::Button::Left,
        PlatformEvent::MouseMoved, 1, PlatformEvent::NoModifiers,
        PlatformMouseEvent::RealOrIndistinguishable, 0);
    MouseEvent* mouseEvent = MouseEvent::create(
        EventTypeNames::mousemove, domWindow, platformMouseEvent, 0, document);
    WebMouseEventBuilder webMouseBuilder(view, documentLayoutView, *mouseEvent);

    EXPECT_EQ(10, webMouseBuilder.x);
    EXPECT_EQ(10, webMouseBuilder.y);
    EXPECT_EQ(10, webMouseBuilder.globalX);
    EXPECT_EQ(10, webMouseBuilder.globalY);
    EXPECT_EQ(10, webMouseBuilder.windowX);
    EXPECT_EQ(10, webMouseBuilder.windowY);
  }

  {
    PlatformMouseEvent platformMouseEvent(
        IntPoint(10, 10), IntPoint(10, 10),
        WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved, 1,
        PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
        0);
    MouseEvent* mouseEvent = MouseEvent::create(
        EventTypeNames::mousemove, domWindow, platformMouseEvent, 0, document);
    WebMouseEventBuilder webMouseBuilder(view, documentLayoutView, *mouseEvent);
    EXPECT_EQ(WebMouseEvent::Button::NoButton, webMouseBuilder.button);
  }

  {
    PlatformGestureEvent platformGestureEvent(
        PlatformEvent::GestureScrollUpdate, IntPoint(10, 12), IntPoint(20, 22),
        IntSize(25, 27), 0, PlatformEvent::NoModifiers,
        PlatformGestureSourceTouchscreen);
    platformGestureEvent.setScrollGestureData(30, 32, ScrollByPrecisePixel, 40,
                                              42, ScrollInertialPhaseMomentum,
                                              true, -1 /* null plugin id */);
    // FIXME: GestureEvent does not preserve velocityX, velocityY,
    // or preventPropagation. It also fails to scale
    // coordinates (x, y, deltaX, deltaY) to the page scale. This
    // may lead to unexpected bugs if a PlatformGestureEvent is
    // transformed into WebGestureEvent and back.
    GestureEvent* gestureEvent =
        GestureEvent::create(domWindow, platformGestureEvent);
    WebGestureEventBuilder webGestureBuilder(documentLayoutView, *gestureEvent);

    EXPECT_EQ(10, webGestureBuilder.x);
    EXPECT_EQ(12, webGestureBuilder.y);
    EXPECT_EQ(20, webGestureBuilder.globalX);
    EXPECT_EQ(22, webGestureBuilder.globalY);
    EXPECT_EQ(30, webGestureBuilder.data.scrollUpdate.deltaX);
    EXPECT_EQ(32, webGestureBuilder.data.scrollUpdate.deltaY);
    EXPECT_EQ(0, webGestureBuilder.data.scrollUpdate.velocityX);
    EXPECT_EQ(0, webGestureBuilder.data.scrollUpdate.velocityY);
    EXPECT_EQ(WebGestureEvent::MomentumPhase,
              webGestureBuilder.data.scrollUpdate.inertialPhase);
    EXPECT_FALSE(webGestureBuilder.data.scrollUpdate.preventPropagation);
    EXPECT_EQ(WebGestureDeviceTouchscreen, webGestureBuilder.sourceDevice);
  }

  {
    Touch* touch =
        Touch::create(toLocalFrame(webViewImpl->page()->mainFrame()), document,
                      0, FloatPoint(10, 9.5), FloatPoint(3.5, 2),
                      FloatSize(4, 4.5), 0, 0, String());
    TouchList* touchList = TouchList::create();
    touchList->append(touch);
    TouchEvent* touchEvent = TouchEvent::create(
        touchList, touchList, touchList, EventTypeNames::touchmove, domWindow,
        PlatformEvent::NoModifiers, false, false, true, 0, TouchActionAuto);

    WebTouchEventBuilder webTouchBuilder(documentLayoutView, *touchEvent);
    ASSERT_EQ(1u, webTouchBuilder.touchesLength);
    EXPECT_EQ(10, webTouchBuilder.touches[0].screenPosition.x);
    EXPECT_FLOAT_EQ(9.5, webTouchBuilder.touches[0].screenPosition.y);
    EXPECT_FLOAT_EQ(3.5, webTouchBuilder.touches[0].position.x);
    EXPECT_FLOAT_EQ(2, webTouchBuilder.touches[0].position.y);
    EXPECT_FLOAT_EQ(4, webTouchBuilder.touches[0].radiusX);
    EXPECT_FLOAT_EQ(4.5, webTouchBuilder.touches[0].radiusY);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webTouchBuilder.dispatchType);
  }
}

TEST(WebInputEventConversionTest, InputEventsTransform) {
  const std::string baseURL("http://www.test2.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  webViewImpl->settings()->setViewportEnabled(true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  webViewImpl->setPageScaleFactor(2);
  webViewImpl->mainFrameImpl()->setInputEventsTransformForEmulation(
      IntSize(10, 20), 1.5);

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 100;
    webMouseEvent.y = 110;
    webMouseEvent.windowX = 100;
    webMouseEvent.windowY = 110;
    webMouseEvent.globalX = 100;
    webMouseEvent.globalY = 110;
    webMouseEvent.movementX = 60;
    webMouseEvent.movementY = 60;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(30, platformMouseBuilder.position().x());
    EXPECT_EQ(30, platformMouseBuilder.position().y());
    EXPECT_EQ(100, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(110, platformMouseBuilder.globalPosition().y());
    EXPECT_EQ(20, platformMouseBuilder.movementDelta().x());
    EXPECT_EQ(20, platformMouseBuilder.movementDelta().y());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollUpdate;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.x = 100;
    webGestureEvent.y = 110;
    webGestureEvent.globalX = 100;
    webGestureEvent.globalY = 110;
    webGestureEvent.data.scrollUpdate.deltaX = 60;
    webGestureEvent.data.scrollUpdate.deltaY = 60;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(30, platformGestureBuilder.position().x());
    EXPECT_EQ(30, platformGestureBuilder.position().y());
    EXPECT_EQ(100, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(110, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(20, platformGestureBuilder.deltaX());
    EXPECT_EQ(20, platformGestureBuilder.deltaY());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTap;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tap.width = 30;
    webGestureEvent.data.tap.height = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTapUnconfirmed;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tap.width = 30;
    webGestureEvent.data.tap.height = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTapDown;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.tapDown.width = 30;
    webGestureEvent.data.tapDown.height = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureShowPress;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.showPress.width = 30;
    webGestureEvent.data.showPress.height = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureLongPress;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.longPress.width = 30;
    webGestureEvent.data.longPress.height = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTwoFingerTap;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.data.twoFingerTap.firstFingerWidth = 30;
    webGestureEvent.data.twoFingerTap.firstFingerHeight = 30;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10, platformGestureBuilder.area().width());
    EXPECT_EQ(10, platformGestureBuilder.area().height());
  }

  {
    WebTouchEvent webTouchEvent;
    webTouchEvent.type = WebInputEvent::TouchMove;
    webTouchEvent.touchesLength = 1;
    webTouchEvent.touches[0].state = WebTouchPoint::StateMoved;
    webTouchEvent.touches[0].screenPosition.x = 100;
    webTouchEvent.touches[0].screenPosition.y = 110;
    webTouchEvent.touches[0].position.x = 100;
    webTouchEvent.touches[0].position.y = 110;
    webTouchEvent.touches[0].radiusX = 30;
    webTouchEvent.touches[0].radiusY = 30;

    PlatformTouchEventBuilder platformTouchBuilder(view, webTouchEvent);
    EXPECT_FLOAT_EQ(100, platformTouchBuilder.touchPoints()[0].screenPos().x());
    EXPECT_FLOAT_EQ(110, platformTouchBuilder.touchPoints()[0].screenPos().y());
    EXPECT_FLOAT_EQ(30, platformTouchBuilder.touchPoints()[0].pos().x());
    EXPECT_FLOAT_EQ(30, platformTouchBuilder.touchPoints()[0].pos().y());
    EXPECT_FLOAT_EQ(10, platformTouchBuilder.touchPoints()[0].radius().width());
    EXPECT_FLOAT_EQ(10,
                    platformTouchBuilder.touchPoints()[0].radius().height());
  }
}

TEST(WebInputEventConversionTest, InputEventsConversions) {
  const std::string baseURL("http://www.test3.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();
  Document* document =
      toLocalFrame(webViewImpl->page()->mainFrame())->document();
  LocalDOMWindow* domWindow = document->domWindow();
  LayoutViewItem documentLayoutView = document->layoutViewItem();

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureTap;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.x = 10;
    webGestureEvent.y = 10;
    webGestureEvent.globalX = 10;
    webGestureEvent.globalY = 10;
    webGestureEvent.data.tap.tapCount = 1;
    webGestureEvent.data.tap.width = 10;
    webGestureEvent.data.tap.height = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(10.f, platformGestureBuilder.position().x());
    EXPECT_EQ(10.f, platformGestureBuilder.position().y());
    EXPECT_EQ(10.f, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(10.f, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(1, platformGestureBuilder.tapCount());

    GestureEvent* coreGestureEvent =
        GestureEvent::create(domWindow, platformGestureBuilder);
    WebGestureEventBuilder recreatedWebGestureEvent(documentLayoutView,
                                                    *coreGestureEvent);
    EXPECT_EQ(webGestureEvent.type, recreatedWebGestureEvent.type);
    EXPECT_EQ(webGestureEvent.x, recreatedWebGestureEvent.x);
    EXPECT_EQ(webGestureEvent.y, recreatedWebGestureEvent.y);
    EXPECT_EQ(webGestureEvent.globalX, recreatedWebGestureEvent.globalX);
    EXPECT_EQ(webGestureEvent.globalY, recreatedWebGestureEvent.globalY);
    EXPECT_EQ(webGestureEvent.data.tap.tapCount,
              recreatedWebGestureEvent.data.tap.tapCount);
  }
}

TEST(WebInputEventConversionTest, VisualViewportOffset) {
  const std::string baseURL("http://www.test4.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  webViewImpl->setPageScaleFactor(2);

  IntPoint visualOffset(35, 60);
  webViewImpl->page()->frameHost().visualViewport().setLocation(visualOffset);

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 10;
    webMouseEvent.y = 10;
    webMouseEvent.windowX = 10;
    webMouseEvent.windowY = 10;
    webMouseEvent.globalX = 10;
    webMouseEvent.globalY = 10;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(5 + visualOffset.x(), platformMouseBuilder.position().x());
    EXPECT_EQ(5 + visualOffset.y(), platformMouseBuilder.position().y());
    EXPECT_EQ(10, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(10, platformMouseBuilder.globalPosition().y());
  }

  {
    WebMouseWheelEvent webMouseWheelEvent;
    webMouseWheelEvent.type = WebInputEvent::MouseWheel;
    webMouseWheelEvent.x = 10;
    webMouseWheelEvent.y = 10;
    webMouseWheelEvent.windowX = 10;
    webMouseWheelEvent.windowY = 10;
    webMouseWheelEvent.globalX = 10;
    webMouseWheelEvent.globalY = 10;

    PlatformWheelEventBuilder platformWheelBuilder(view, webMouseWheelEvent);
    EXPECT_EQ(5 + visualOffset.x(), platformWheelBuilder.position().x());
    EXPECT_EQ(5 + visualOffset.y(), platformWheelBuilder.position().y());
    EXPECT_EQ(10, platformWheelBuilder.globalPosition().x());
    EXPECT_EQ(10, platformWheelBuilder.globalPosition().y());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollUpdate;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
    webGestureEvent.x = 10;
    webGestureEvent.y = 10;
    webGestureEvent.globalX = 10;
    webGestureEvent.globalY = 10;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(5 + visualOffset.x(), platformGestureBuilder.position().x());
    EXPECT_EQ(5 + visualOffset.y(), platformGestureBuilder.position().y());
    EXPECT_EQ(10, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(10, platformGestureBuilder.globalPosition().y());
  }

  {
    WebTouchEvent webTouchEvent;
    webTouchEvent.type = WebInputEvent::TouchMove;
    webTouchEvent.touchesLength = 1;
    webTouchEvent.touches[0].state = WebTouchPoint::StateMoved;
    webTouchEvent.touches[0].screenPosition.x = 10.6f;
    webTouchEvent.touches[0].screenPosition.y = 10.4f;
    webTouchEvent.touches[0].position.x = 10.6f;
    webTouchEvent.touches[0].position.y = 10.4f;

    EXPECT_FLOAT_EQ(10.6f, webTouchEvent.touches[0].screenPosition.x);
    EXPECT_FLOAT_EQ(10.4f, webTouchEvent.touches[0].screenPosition.y);
    EXPECT_FLOAT_EQ(10.6f, webTouchEvent.touches[0].position.x);
    EXPECT_FLOAT_EQ(10.4f, webTouchEvent.touches[0].position.y);

    PlatformTouchEventBuilder platformTouchBuilder(view, webTouchEvent);
    EXPECT_FLOAT_EQ(10.6f,
                    platformTouchBuilder.touchPoints()[0].screenPos().x());
    EXPECT_FLOAT_EQ(10.4f,
                    platformTouchBuilder.touchPoints()[0].screenPos().y());
    EXPECT_FLOAT_EQ(5.3f + visualOffset.x(),
                    platformTouchBuilder.touchPoints()[0].pos().x());
    EXPECT_FLOAT_EQ(5.2f + visualOffset.y(),
                    platformTouchBuilder.touchPoints()[0].pos().y());
  }
}

TEST(WebInputEventConversionTest, ElasticOverscroll) {
  const std::string baseURL("http://www.test5.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  FloatSize elasticOverscroll(10, -20);
  webViewImpl->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                   elasticOverscroll, 1.0f, 0.0f);

  // Just elastic overscroll.
  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 10;
    webMouseEvent.y = 50;
    webMouseEvent.windowX = 10;
    webMouseEvent.windowY = 50;
    webMouseEvent.globalX = 10;
    webMouseEvent.globalY = 50;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(webMouseEvent.x + elasticOverscroll.width(),
              platformMouseBuilder.position().x());
    EXPECT_EQ(webMouseEvent.y + elasticOverscroll.height(),
              platformMouseBuilder.position().y());
    EXPECT_EQ(webMouseEvent.globalX, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(webMouseEvent.globalY, platformMouseBuilder.globalPosition().y());
  }

  // Elastic overscroll and pinch-zoom (this doesn't actually ever happen,
  // but ensure that if it were to, the overscroll would be applied after the
  // pinch-zoom).
  float pageScale = 2;
  webViewImpl->setPageScaleFactor(pageScale);
  IntPoint visualOffset(35, 60);
  webViewImpl->page()->frameHost().visualViewport().setLocation(visualOffset);
  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 10;
    webMouseEvent.y = 10;
    webMouseEvent.windowX = 10;
    webMouseEvent.windowY = 10;
    webMouseEvent.globalX = 10;
    webMouseEvent.globalY = 10;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(webMouseEvent.x / pageScale + visualOffset.x() +
                  elasticOverscroll.width(),
              platformMouseBuilder.position().x());
    EXPECT_EQ(webMouseEvent.y / pageScale + visualOffset.y() +
                  elasticOverscroll.height(),
              platformMouseBuilder.position().y());
    EXPECT_EQ(webMouseEvent.globalX, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(webMouseEvent.globalY, platformMouseBuilder.globalPosition().y());
  }
}

// Page reload/navigation should not reset elastic overscroll.
TEST(WebInputEventConversionTest, ElasticOverscrollWithPageReload) {
  const std::string baseURL("http://www.test6.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  FloatSize elasticOverscroll(10, -20);
  webViewImpl->applyViewportDeltas(WebFloatSize(), WebFloatSize(),
                                   elasticOverscroll, 1.0f, 0.0f);
  FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  // Just elastic overscroll.
  {
    WebMouseEvent webMouseEvent;
    webMouseEvent.type = WebInputEvent::MouseMove;
    webMouseEvent.x = 10;
    webMouseEvent.y = 50;
    webMouseEvent.windowX = 10;
    webMouseEvent.windowY = 50;
    webMouseEvent.globalX = 10;
    webMouseEvent.globalY = 50;

    PlatformMouseEventBuilder platformMouseBuilder(view, webMouseEvent);
    EXPECT_EQ(webMouseEvent.x + elasticOverscroll.width(),
              platformMouseBuilder.position().x());
    EXPECT_EQ(webMouseEvent.y + elasticOverscroll.height(),
              platformMouseBuilder.position().y());
    EXPECT_EQ(webMouseEvent.globalX, platformMouseBuilder.globalPosition().x());
    EXPECT_EQ(webMouseEvent.globalY, platformMouseBuilder.globalPosition().y());
  }
}

TEST(WebInputEventConversionTest, WebMouseWheelEventBuilder) {
  const std::string baseURL("http://www.test7.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  Document* document =
      toLocalFrame(webViewImpl->page()->mainFrame())->document();
  {
    WheelEvent* event = WheelEvent::create(
        FloatPoint(1, 3), FloatPoint(5, 10), WheelEvent::kDomDeltaPage,
        document->domWindow(), IntPoint(2, 6), IntPoint(10, 30),
        PlatformEvent::CtrlKey, 0, 0, -1 /* null plugin id */,
        true /* hasPreciseScrollingDeltas */, Event::RailsModeHorizontal,
        true /*cancelable*/
#if OS(MACOSX)
        ,
        WheelEventPhaseBegan, WheelEventPhaseChanged
#endif
        );
    WebMouseWheelEventBuilder webMouseWheel(
        toLocalFrame(webViewImpl->page()->mainFrame())->view(),
        document->layoutViewItem(), *event);
    EXPECT_EQ(1, webMouseWheel.wheelTicksX);
    EXPECT_EQ(3, webMouseWheel.wheelTicksY);
    EXPECT_EQ(5, webMouseWheel.deltaX);
    EXPECT_EQ(10, webMouseWheel.deltaY);
    EXPECT_EQ(2, webMouseWheel.globalX);
    EXPECT_EQ(6, webMouseWheel.globalY);
    EXPECT_EQ(10, webMouseWheel.windowX);
    EXPECT_EQ(30, webMouseWheel.windowY);
    EXPECT_TRUE(webMouseWheel.scrollByPage);
    EXPECT_EQ(WebInputEvent::ControlKey, webMouseWheel.modifiers);
    EXPECT_EQ(WebInputEvent::RailsModeHorizontal, webMouseWheel.railsMode);
    EXPECT_TRUE(webMouseWheel.hasPreciseScrollingDeltas);
    EXPECT_EQ(WebInputEvent::Blocking, webMouseWheel.dispatchType);
#if OS(MACOSX)
    EXPECT_EQ(WebMouseWheelEvent::PhaseBegan, webMouseWheel.phase);
    EXPECT_EQ(WebMouseWheelEvent::PhaseChanged, webMouseWheel.momentumPhase);
#endif
  }

  {
    WheelEvent* event = WheelEvent::create(
        FloatPoint(1, 3), FloatPoint(5, 10), WheelEvent::kDomDeltaPage,
        document->domWindow(), IntPoint(2, 6), IntPoint(10, 30),
        PlatformEvent::CtrlKey, 0, 0, -1 /* null plugin id */,
        true /* hasPreciseScrollingDeltas */, Event::RailsModeHorizontal, false
#if OS(MACOSX)
        ,
        WheelEventPhaseNone, WheelEventPhaseNone
#endif
        );
    WebMouseWheelEventBuilder webMouseWheel(
        toLocalFrame(webViewImpl->page()->mainFrame())->view(),
        document->layoutViewItem(), *event);
    EXPECT_EQ(WebInputEvent::EventNonBlocking, webMouseWheel.dispatchType);
  }
}

TEST(WebInputEventConversionTest, PlatformWheelEventBuilder) {
  const std::string baseURL("http://www.test8.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  {
    WebMouseWheelEvent webMouseWheelEvent;
    webMouseWheelEvent.type = WebInputEvent::MouseWheel;
    webMouseWheelEvent.x = 0;
    webMouseWheelEvent.y = 5;
    webMouseWheelEvent.deltaX = 10;
    webMouseWheelEvent.deltaY = 15;
    webMouseWheelEvent.modifiers = WebInputEvent::ControlKey;
    webMouseWheelEvent.hasPreciseScrollingDeltas = true;
    webMouseWheelEvent.railsMode = WebInputEvent::RailsModeHorizontal;
    webMouseWheelEvent.phase = WebMouseWheelEvent::PhaseBegan;
    webMouseWheelEvent.momentumPhase = WebMouseWheelEvent::PhaseChanged;

    PlatformWheelEventBuilder platformWheelBuilder(view, webMouseWheelEvent);
    EXPECT_EQ(0, platformWheelBuilder.position().x());
    EXPECT_EQ(5, platformWheelBuilder.position().y());
    EXPECT_EQ(10, platformWheelBuilder.deltaX());
    EXPECT_EQ(15, platformWheelBuilder.deltaY());
    EXPECT_EQ(PlatformEvent::CtrlKey, platformWheelBuilder.getModifiers());
    EXPECT_TRUE(platformWheelBuilder.hasPreciseScrollingDeltas());
    EXPECT_EQ(platformWheelBuilder.getRailsMode(),
              PlatformEvent::RailsModeHorizontal);
#if OS(MACOSX)
    EXPECT_EQ(PlatformWheelEventPhaseBegan, platformWheelBuilder.phase());
    EXPECT_EQ(PlatformWheelEventPhaseChanged,
              platformWheelBuilder.momentumPhase());
#endif
  }

  {
    WebMouseWheelEvent webMouseWheelEvent;
    webMouseWheelEvent.type = WebInputEvent::MouseWheel;
    webMouseWheelEvent.x = 5;
    webMouseWheelEvent.y = 0;
    webMouseWheelEvent.deltaX = 15;
    webMouseWheelEvent.deltaY = 10;
    webMouseWheelEvent.modifiers = WebInputEvent::ShiftKey;
    webMouseWheelEvent.hasPreciseScrollingDeltas = false;
    webMouseWheelEvent.railsMode = WebInputEvent::RailsModeFree;
    webMouseWheelEvent.phase = WebMouseWheelEvent::PhaseNone;
    webMouseWheelEvent.momentumPhase = WebMouseWheelEvent::PhaseNone;

    PlatformWheelEventBuilder platformWheelBuilder(view, webMouseWheelEvent);
    EXPECT_EQ(5, platformWheelBuilder.position().x());
    EXPECT_EQ(0, platformWheelBuilder.position().y());
    EXPECT_EQ(15, platformWheelBuilder.deltaX());
    EXPECT_EQ(10, platformWheelBuilder.deltaY());
    EXPECT_EQ(PlatformEvent::ShiftKey, platformWheelBuilder.getModifiers());
    EXPECT_FALSE(platformWheelBuilder.hasPreciseScrollingDeltas());
    EXPECT_EQ(platformWheelBuilder.getRailsMode(),
              PlatformEvent::RailsModeFree);
#if OS(MACOSX)
    EXPECT_EQ(PlatformWheelEventPhaseNone, platformWheelBuilder.phase());
    EXPECT_EQ(PlatformWheelEventPhaseNone,
              platformWheelBuilder.momentumPhase());
#endif
  }

  {
    WebMouseWheelEvent webMouseWheelEvent;
    webMouseWheelEvent.type = WebInputEvent::MouseWheel;
    webMouseWheelEvent.x = 5;
    webMouseWheelEvent.y = 0;
    webMouseWheelEvent.deltaX = 15;
    webMouseWheelEvent.deltaY = 10;
    webMouseWheelEvent.modifiers = WebInputEvent::AltKey;
    webMouseWheelEvent.hasPreciseScrollingDeltas = true;
    webMouseWheelEvent.railsMode = WebInputEvent::RailsModeVertical;
    webMouseWheelEvent.phase = WebMouseWheelEvent::PhaseNone;
    webMouseWheelEvent.momentumPhase = WebMouseWheelEvent::PhaseNone;

    PlatformWheelEventBuilder platformWheelBuilder(view, webMouseWheelEvent);
    EXPECT_EQ(5, platformWheelBuilder.position().x());
    EXPECT_EQ(0, platformWheelBuilder.position().y());
    EXPECT_EQ(15, platformWheelBuilder.deltaX());
    EXPECT_EQ(10, platformWheelBuilder.deltaY());
    EXPECT_EQ(PlatformEvent::AltKey, platformWheelBuilder.getModifiers());
    EXPECT_TRUE(platformWheelBuilder.hasPreciseScrollingDeltas());
    EXPECT_EQ(platformWheelBuilder.getRailsMode(),
              PlatformEvent::RailsModeVertical);
#if OS(MACOSX)
    EXPECT_EQ(PlatformWheelEventPhaseNone, platformWheelBuilder.phase());
    EXPECT_EQ(PlatformWheelEventPhaseNone,
              platformWheelBuilder.momentumPhase());
#endif
  }
}

TEST(WebInputEventConversionTest, PlatformGestureEventBuilder) {
  const std::string baseURL("http://www.test9.com/");
  const std::string fileName("fixed_layout.html");

  URLTestHelpers::registerMockedURLFromBaseURL(
      WebString::fromUTF8(baseURL.c_str()),
      WebString::fromUTF8("fixed_layout.html"));
  FrameTestHelpers::WebViewHelper webViewHelper;
  WebViewImpl* webViewImpl =
      webViewHelper.initializeAndLoad(baseURL + fileName, true);
  int pageWidth = 640;
  int pageHeight = 480;
  webViewImpl->resize(WebSize(pageWidth, pageHeight));
  webViewImpl->updateAllLifecyclePhases();

  FrameView* view = toLocalFrame(webViewImpl->page()->mainFrame())->view();

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollBegin;
    webGestureEvent.x = 0;
    webGestureEvent.y = 5;
    webGestureEvent.globalX = 10;
    webGestureEvent.globalY = 15;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchpad;
    webGestureEvent.resendingPluginId = 2;
    webGestureEvent.data.scrollBegin.inertialPhase =
        WebGestureEvent::MomentumPhase;
    webGestureEvent.data.scrollBegin.synthetic = true;
    webGestureEvent.data.scrollBegin.deltaXHint = 100;
    webGestureEvent.data.scrollBegin.deltaYHint = 10;
    webGestureEvent.data.scrollBegin.deltaHintUnits = WebGestureEvent::Pixels;
    webGestureEvent.uniqueTouchEventId = 12345U;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(PlatformGestureSourceTouchpad, platformGestureBuilder.source());
    EXPECT_EQ(2, platformGestureBuilder.resendingPluginId());
    EXPECT_EQ(0, platformGestureBuilder.position().x());
    EXPECT_EQ(5, platformGestureBuilder.position().y());
    EXPECT_EQ(10, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(15, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(ScrollInertialPhaseMomentum,
              platformGestureBuilder.inertialPhase());
    EXPECT_TRUE(platformGestureBuilder.synthetic());
    EXPECT_EQ(100, platformGestureBuilder.deltaX());
    EXPECT_EQ(10, platformGestureBuilder.deltaY());
    EXPECT_EQ(ScrollGranularity::ScrollByPixel,
              platformGestureBuilder.deltaUnits());
    EXPECT_EQ(12345U, platformGestureBuilder.uniqueTouchEventId());
  }

  {
    WebGestureEvent webGestureEvent;
    webGestureEvent.type = WebInputEvent::GestureScrollEnd;
    webGestureEvent.x = 0;
    webGestureEvent.y = 5;
    webGestureEvent.globalX = 10;
    webGestureEvent.globalY = 15;
    webGestureEvent.sourceDevice = WebGestureDeviceTouchpad;
    webGestureEvent.resendingPluginId = 2;
    webGestureEvent.data.scrollEnd.inertialPhase =
        WebGestureEvent::NonMomentumPhase;
    webGestureEvent.data.scrollEnd.synthetic = true;
    webGestureEvent.data.scrollEnd.deltaUnits = WebGestureEvent::Page;
    webGestureEvent.uniqueTouchEventId = 12345U;

    PlatformGestureEventBuilder platformGestureBuilder(view, webGestureEvent);
    EXPECT_EQ(PlatformGestureSourceTouchpad, platformGestureBuilder.source());
    EXPECT_EQ(2, platformGestureBuilder.resendingPluginId());
    EXPECT_EQ(0, platformGestureBuilder.position().x());
    EXPECT_EQ(5, platformGestureBuilder.position().y());
    EXPECT_EQ(10, platformGestureBuilder.globalPosition().x());
    EXPECT_EQ(15, platformGestureBuilder.globalPosition().y());
    EXPECT_EQ(ScrollInertialPhaseNonMomentum,
              platformGestureBuilder.inertialPhase());
    EXPECT_TRUE(platformGestureBuilder.synthetic());
    EXPECT_EQ(ScrollGranularity::ScrollByPage,
              platformGestureBuilder.deltaUnits());
    EXPECT_EQ(12345U, platformGestureBuilder.uniqueTouchEventId());
  }
}

}  // namespace blink