Pass MotionEvent tilt angles to Blink on Android.

This extends event handlers to pass tilt angles from Android MotionEvent
to Blink touch points, so that on the Blink side, PointerEvent tiltX and
tiltY can be filled with real tilt angles.

This CL is a part of a patch series:
 1. https://codereview.chromium.org/1253183005/
    for new WebPointerProperties fields
 2. https://codereview.chromium.org/1260693003/
    for eventSender web pointer property support
 3. https://codereview.chromium.org/1192563002/
    for handling tilt in Blink event handlers
 4. https://codereview.chromium.org/1417803002/
    (this)

This CL is based on the abandoned CL at
https://codereview.chromium.org/1187273004/

BUG=514360

Review URL: https://codereview.chromium.org/1417803002

Cr-Commit-Position: refs/heads/master@{#357471}

11 files changed, 208 insertions, 47 deletions

diff --git a/content/browser/android/content_view_core_impl.cc b/content/browser/android/content_view_core_impl.cc
index 6046ba2..18b8722 100644
--- a/content/browser/android/content_view_core_impl.cc
+++ b/content/browser/android/content_view_core_impl.cc
@@ -879,6 +879,8 @@ jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
                                            jfloat touch_minor_1,
                                            jfloat orientation_0,
                                            jfloat orientation_1,
+                                           jfloat tilt_0,
+                                           jfloat tilt_1,
                                            jfloat raw_pos_x,
                                            jfloat raw_pos_y,
                                            jint android_tool_type_0,
@@ -897,6 +899,7 @@ jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
                                        touch_major_0,
                                        touch_minor_0,
                                        orientation_0,
+                                       tilt_0,
                                        android_tool_type_0);
   MotionEventAndroid::Pointer pointer1(pointer_id_1,
                                        pos_x_1,
@@ -904,6 +907,7 @@ jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
                                        touch_major_1,
                                        touch_minor_1,
                                        orientation_1,
+                                       tilt_1,
                                        android_tool_type_1);
   MotionEventAndroid event(1.f / dpi_scale(),
                            env,
diff --git a/content/browser/android/content_view_core_impl.h b/content/browser/android/content_view_core_impl.h
index 4fd7ccb..55157a1 100644
--- a/content/browser/android/content_view_core_impl.h
+++ b/content/browser/android/content_view_core_impl.h
@@ -105,6 +105,8 @@ class ContentViewCoreImpl : public ContentViewCore,
                         jfloat touch_minor_1,
                         jfloat orientation_0,
                         jfloat orientation_1,
+                        jfloat tilt_0,
+                        jfloat tilt_1,
                         jfloat raw_pos_x,
                         jfloat raw_pos_y,
                         jint android_tool_type_0,
diff --git a/content/browser/renderer_host/input/motion_event_android.cc b/content/browser/renderer_host/input/motion_event_android.cc
index 4d30a3f..6392e90 100644
--- a/content/browser/renderer_host/input/motion_event_android.cc
+++ b/content/browser/renderer_host/input/motion_event_android.cc
@@ -129,6 +129,7 @@ MotionEventAndroid::Pointer::Pointer(jint id,
                                      jfloat touch_major_pixels,
                                      jfloat touch_minor_pixels,
                                      jfloat orientation_rad,
+                                     jfloat tilt_rad,
                                      jint tool_type)
     : id(id),
       pos_x_pixels(pos_x_pixels),
@@ -136,6 +137,7 @@ MotionEventAndroid::Pointer::Pointer(jint id,
       touch_major_pixels(touch_major_pixels),
       touch_minor_pixels(touch_minor_pixels),
       orientation_rad(orientation_rad),
+      tilt_rad(tilt_rad),
       tool_type(tool_type) {
 }
 
@@ -144,6 +146,7 @@ MotionEventAndroid::CachedPointer::CachedPointer()
       touch_major(0),
       touch_minor(0),
       orientation(0),
+      tilt(0),
       tool_type(TOOL_TYPE_UNKNOWN) {
 }
 
@@ -273,6 +276,16 @@ float MotionEventAndroid::GetPressure(size_t pointer_index) const {
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
+float MotionEventAndroid::GetTilt(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, cached_pointer_count_);
+  if (pointer_index < MAX_POINTERS_TO_CACHE)
+    return cached_pointers_[pointer_index].tilt;
+  if (!event_.obj())
+    return 0.f;
+  return ToValidFloat(Java_MotionEvent_getAxisValueF_I_I(
+      AttachCurrentThread(), event_.obj(), AXIS_TILT, pointer_index));
+}
+
 base::TimeTicks MotionEventAndroid::GetEventTime() const {
   return cached_time_;
 }
@@ -336,6 +349,7 @@ MotionEventAndroid::CachedPointer MotionEventAndroid::FromAndroidPointer(
   result.touch_major = ToDips(pointer.touch_major_pixels);
   result.touch_minor = ToDips(pointer.touch_minor_pixels);
   result.orientation = ToValidFloat(pointer.orientation_rad);
+  result.tilt = ToValidFloat(pointer.tilt_rad);
   result.tool_type = FromAndroidToolType(pointer.tool_type);
   return result;
 }
diff --git a/content/browser/renderer_host/input/motion_event_android.h b/content/browser/renderer_host/input/motion_event_android.h
index bf4dfed..d581ce0 100644
--- a/content/browser/renderer_host/input/motion_event_android.h
+++ b/content/browser/renderer_host/input/motion_event_android.h
@@ -29,6 +29,7 @@ class CONTENT_EXPORT MotionEventAndroid : public ui::MotionEvent {
             jfloat touch_major_pixels,
             jfloat touch_minor_pixels,
             jfloat orientation_rad,
+            jfloat tilt_rad,
             jint tool_type);
     jint id;
     jfloat pos_x_pixels;
@@ -36,6 +37,7 @@ class CONTENT_EXPORT MotionEventAndroid : public ui::MotionEvent {
     jfloat touch_major_pixels;
     jfloat touch_minor_pixels;
     jfloat orientation_rad;
+    jfloat tilt_rad;
     jint tool_type;
   };
 
@@ -71,6 +73,7 @@ class CONTENT_EXPORT MotionEventAndroid : public ui::MotionEvent {
   float GetTouchMinor(size_t pointer_index) const override;
   float GetOrientation(size_t pointer_index) const override;
   float GetPressure(size_t pointer_index) const override;
+  float GetTilt(size_t pointer_index) const override;
   base::TimeTicks GetEventTime() const override;
   size_t GetHistorySize() const override;
   base::TimeTicks GetHistoricalEventTime(
@@ -120,6 +123,7 @@ class CONTENT_EXPORT MotionEventAndroid : public ui::MotionEvent {
     float touch_major;
     float touch_minor;
     float orientation;
+    float tilt;
     ToolType tool_type;
   } cached_pointers_[MAX_POINTERS_TO_CACHE];
 
diff --git a/content/browser/renderer_host/input/motion_event_android_unittest.cc b/content/browser/renderer_host/input/motion_event_android_unittest.cc
index 9a33b31..c888aca 100644
--- a/content/browser/renderer_host/input/motion_event_android_unittest.cc
+++ b/content/browser/renderer_host/input/motion_event_android_unittest.cc
@@ -39,9 +39,9 @@ TEST(MotionEventAndroidTest, Constructor) {
   base::TimeTicks event_time =
       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
   MotionEventAndroid::Pointer p0(
-      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, kAndroidToolTypeFinger);
+      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, 0.2f, kAndroidToolTypeFinger);
   MotionEventAndroid::Pointer p1(
-      2, -13.7f, 7.13f, 3.5f, 12.1f, -0.1f, kAndroidToolTypeFinger);
+      2, -13.7f, 7.13f, 3.5f, 12.1f, -0.1f, -0.4f, kAndroidToolTypeFinger);
   float raw_offset = -3.f;
   int pointer_count = 2;
   int history_size = 0;
@@ -77,6 +77,8 @@ TEST(MotionEventAndroidTest, Constructor) {
   EXPECT_EQ(p1.touch_minor_pixels * kPixToDip, event.GetTouchMinor(1));
   EXPECT_EQ(p0.orientation_rad, event.GetOrientation(0));
   EXPECT_EQ(p1.orientation_rad, event.GetOrientation(1));
+  EXPECT_EQ(p0.tilt_rad, event.GetTilt(0));
+  EXPECT_EQ(p1.tilt_rad, event.GetTilt(1));
   EXPECT_EQ(p0.id, event.GetPointerId(0));
   EXPECT_EQ(p1.id, event.GetPointerId(1));
   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(0));
@@ -90,8 +92,8 @@ TEST(MotionEventAndroidTest, Constructor) {
 TEST(MotionEventAndroidTest, Clone) {
   const int pointer_count = 1;
   MotionEventAndroid::Pointer p0(
-      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, kAndroidToolTypeFinger);
-  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0);
+      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, 0.2f, kAndroidToolTypeFinger);
+  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0, 0);
   MotionEventAndroid event(kPixToDip,
                            base::android::AttachCurrentThread(),
                            nullptr,
@@ -115,8 +117,8 @@ TEST(MotionEventAndroidTest, Cancel) {
   const int event_time_ms = 5;
   const int pointer_count = 1;
   MotionEventAndroid::Pointer p0(
-      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, kAndroidToolTypeFinger);
-  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0);
+      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, 0.2f, kAndroidToolTypeFinger);
+  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0, 0);
   MotionEventAndroid event(kPixToDip,
                            base::android::AttachCurrentThread(),
                            nullptr,
@@ -148,8 +150,8 @@ TEST(MotionEventAndroidTest, InvalidOrientationsSanitized) {
   int pointer_count = 2;
   float orientation0 = 1e10f;
   float orientation1 = std::numeric_limits<float>::quiet_NaN();
-  MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, orientation0, 0);
-  MotionEventAndroid::Pointer p1(1, 0, 0, 0, 0, orientation1, 0);
+  MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, orientation0, 0, 0);
+  MotionEventAndroid::Pointer p1(1, 0, 0, 0, 0, orientation1, 0, 0);
   MotionEventAndroid event(kPixToDip,
                            base::android::AttachCurrentThread(),
                            nullptr,
@@ -172,8 +174,8 @@ TEST(MotionEventAndroidTest, InvalidOrientationsSanitized) {
 TEST(MotionEventAndroidTest, NonEmptyHistoryForNonMoveEventsSanitized) {
   int pointer_count = 1;
   size_t history_size = 5;
-  MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, 0);
-  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0);
+  MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, 0, 0);
+  MotionEventAndroid::Pointer p1(0, 0, 0, 0, 0, 0, 0, 0);
   MotionEventAndroid event(kPixToDip,
                            base::android::AttachCurrentThread(),
                            nullptr,
@@ -194,9 +196,9 @@ TEST(MotionEventAndroidTest, NonEmptyHistoryForNonMoveEventsSanitized) {
 
 TEST(MotionEventAndroidTest, ActionIndexForPointerDown) {
   MotionEventAndroid::Pointer p0(
-      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, kAndroidToolTypeFinger);
+      1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, 0.2f, kAndroidToolTypeFinger);
   MotionEventAndroid::Pointer p1(
-      2, -13.7f, 7.13f, 3.5f, 12.1f, -0.1f, kAndroidToolTypeFinger);
+      2, -13.7f, 7.13f, 3.5f, 12.1f, -0.1f, -0.4f, kAndroidToolTypeFinger);
   int pointer_count = 2;
   int history_size = 0;
   int action_index = 1;
diff --git a/content/browser/renderer_host/input/motion_event_web.cc b/content/browser/renderer_host/input/motion_event_web.cc
index ddc3037..30f141b 100644
--- a/content/browser/renderer_host/input/motion_event_web.cc
+++ b/content/browser/renderer_host/input/motion_event_web.cc
@@ -130,26 +130,62 @@ float MotionEventWeb::GetTouchMinor(size_t pointer_index) const {
 float MotionEventWeb::GetOrientation(size_t pointer_index) const {
   DCHECK_LT(pointer_index, GetPointerCount());
 
-  float rotation_angle_rad = event_.touches[pointer_index].rotationAngle
+  float orientation_rad = event_.touches[pointer_index].rotationAngle
       * M_PI / 180.f;
-  DCHECK(0 <= rotation_angle_rad && rotation_angle_rad <= M_PI_2)
+  DCHECK(0 <= orientation_rad && orientation_rad <= M_PI_2)
       << "Unexpected touch rotation angle";
 
-  if (event_.touches[pointer_index].radiusX
-      > event_.touches[pointer_index].radiusY) {
+  if (GetToolType(pointer_index) == TOOL_TYPE_STYLUS) {
+    const WebPointerProperties& pointer = event_.touches[pointer_index];
+
+    if (pointer.tiltY <= 0 && pointer.tiltX < 0) {
+      // Stylus is tilted to the left away from the user or straight
+      // to the left thus the orientation should be within [pi/2,pi).
+      orientation_rad += static_cast<float>(M_PI_2);
+    } else if (pointer.tiltY < 0 && pointer.tiltX >= 0) {
+      // Stylus is tilted to the right away from the user or straight away
+      // from the user thus the orientation should be within [-pi,-pi/2).
+      orientation_rad -= static_cast<float>(M_PI);
+    } else if (pointer.tiltY >= 0 && pointer.tiltX > 0) {
+      // Stylus is tilted to the right towards the user or straight
+      // to the right thus the orientation should be within [-pi/2,0).
+      orientation_rad -= static_cast<float>(M_PI_2);
+    }
+  } else if (event_.touches[pointer_index].radiusX
+             > event_.touches[pointer_index].radiusY) {
     // The case radiusX == radiusY is omitted from here on purpose: for circles,
     // we want to pass the angle (which could be any value in such cases but
-    // always seem to be set to zero) unchanged.
-    rotation_angle_rad -= (float) M_PI_2;
+    // always seems to be set to zero) unchanged.
+    orientation_rad -= static_cast<float>(M_PI_2);
   }
 
-  return rotation_angle_rad;
+  return orientation_rad;
 }
 
 float MotionEventWeb::GetPressure(size_t pointer_index) const {
   return 0.f;
 }
 
+float MotionEventWeb::GetTilt(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, GetPointerCount());
+
+  if (GetToolType(pointer_index) != TOOL_TYPE_STYLUS)
+    return 0.f;
+
+  const WebPointerProperties& pointer = event_.touches[pointer_index];
+
+  float tilt_x_r = sin(pointer.tiltX * M_PI / 180.f);
+  float tilt_x_z = cos(pointer.tiltX * M_PI / 180.f);
+  float tilt_y_r = sin(pointer.tiltY * M_PI / 180.f);
+  float tilt_y_z = cos(pointer.tiltY * M_PI / 180.f);
+  float r_x = tilt_x_r * tilt_y_z;
+  float r_y = tilt_y_r * tilt_x_z;
+  float r = sqrt(r_x * r_x + r_y * r_y);
+  float z = tilt_x_z * tilt_y_z;
+
+  return atan2(r, z);
+}
+
 base::TimeTicks MotionEventWeb::GetEventTime() const {
   return base::TimeTicks() +
          base::TimeDelta::FromMicroseconds(event_.timeStampSeconds *
diff --git a/content/browser/renderer_host/input/motion_event_web.h b/content/browser/renderer_host/input/motion_event_web.h
index 34e9541..1aac855 100644
--- a/content/browser/renderer_host/input/motion_event_web.h
+++ b/content/browser/renderer_host/input/motion_event_web.h
@@ -5,13 +5,14 @@
 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_MOTION_EVENT_WEB_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_MOTION_EVENT_WEB_H_
 
+#include "content/common/content_export.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/gesture_detection/motion_event.h"
 
 namespace content {
 
 // Implementation of ui::MotionEvent wrapping a WebTouchEvent.
-class MotionEventWeb : public ui::MotionEvent {
+class CONTENT_EXPORT MotionEventWeb : public ui::MotionEvent {
  public:
   explicit MotionEventWeb(const blink::WebTouchEvent& event);
   ~MotionEventWeb() override;
@@ -30,6 +31,7 @@ class MotionEventWeb : public ui::MotionEvent {
   float GetTouchMinor(size_t pointer_index) const override;
   float GetOrientation(size_t pointer_index) const override;
   float GetPressure(size_t pointer_index) const override;
+  float GetTilt(size_t pointer_index) const override;
   base::TimeTicks GetEventTime() const override;
   ToolType GetToolType(size_t pointer_index) const override;
   int GetButtonState() const override;
diff --git a/content/browser/renderer_host/input/motion_event_web_unittest.cc b/content/browser/renderer_host/input/motion_event_web_unittest.cc
new file mode 100644
index 0000000..d126ea7
--- /dev/null
+++ b/content/browser/renderer_host/input/motion_event_web_unittest.cc
@@ -0,0 +1,78 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// MSVC++ requires this to be set before any other includes to get M_PI.
+#define _USE_MATH_DEFINES
+
+#include <cmath>
+
+#include "content/browser/renderer_host/input/motion_event_web.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/blink/blink_event_util.h"
+#include "ui/events/gesture_detection/motion_event_generic.h"
+#include "ui/events/test/motion_event_test_utils.h"
+
+using ui::MotionEvent;
+using ui::MotionEventGeneric;
+using ui::PointerProperties;
+
+namespace content {
+
+TEST(MotionEventWebTest, Constructor) {
+  const float pi = static_cast<float>(M_PI);
+  const float orientations[] = {
+      -pi, -2.f * pi / 3, -pi / 2, -pi / 3, 0.f, pi / 3, pi / 2, 2.f * pi / 3};
+  const float tilts[] = {0.f, pi / 4, pi / 3};
+  const MotionEvent::ToolType tool_types[] = {MotionEvent::TOOL_TYPE_FINGER,
+                                              MotionEvent::TOOL_TYPE_STYLUS,
+                                              MotionEvent::TOOL_TYPE_MOUSE};
+
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  PointerProperties pp;
+  MotionEventGeneric generic_event(MotionEvent::ACTION_MOVE, event_time, pp);
+
+  for (MotionEvent::ToolType tool_type : tool_types) {
+    for (float orientation : orientations) {
+      for (float tilt : tilts) {
+        PointerProperties pp2;
+        pp2.orientation = orientation;
+        pp2.tilt = tilt;
+        pp2.tool_type = tool_type;
+        size_t pointer_index = generic_event.PushPointer(pp2);
+        EXPECT_GT(pointer_index, 0u);
+
+        blink::WebTouchEvent web_touch_event =
+            CreateWebTouchEventFromMotionEvent(generic_event, true);
+
+        MotionEventWeb event(web_touch_event);
+        EXPECT_EQ(tool_type, event.GetToolType(pointer_index));
+        if (tool_type == MotionEvent::TOOL_TYPE_STYLUS) {
+          // Web touch event touch point tilt plane angles are stored as ints,
+          // thus the tilt precision is 1 degree and the error should not be
+          // greater than 0.5 degrees.
+          EXPECT_NEAR(tilt, event.GetTilt(pointer_index), 0.5f * M_PI / 180.f)
+              << " orientation=" << orientation;
+        } else {
+          EXPECT_EQ(0.f, event.GetTilt(pointer_index));
+        }
+        if (tool_type == MotionEvent::TOOL_TYPE_STYLUS && tilt > 0.f) {
+          // Full stylus tilt orientation information survives above event
+          // conversions only if there is a non-zero stylus tilt angle.
+          // See: http://crbug.com/251330
+          EXPECT_NEAR(orientation, event.GetOrientation(pointer_index), 1e-4)
+              << " tilt=" << tilt;
+        } else {
+          // For non-stylus pointers and for styluses with a zero tilt angle,
+          // orientation quadrant information is lost.
+          EXPECT_NEAR(fmod(orientation + M_PI + 1e-4, M_PI_2) - 1e-4,
+                      event.GetOrientation(pointer_index), 1e-4);
+        }
+
+        generic_event.RemovePointerAt(pointer_index);
+      }
+    }
+  }
+}
+
+}  // namespace content
diff --git a/content/browser/renderer_host/input/touch_emulator.cc b/content/browser/renderer_host/input/touch_emulator.cc
index 460716d..e095b9d 100644
--- a/content/browser/renderer_host/input/touch_emulator.cc
+++ b/content/browser/renderer_host/input/touch_emulator.cc
@@ -446,6 +446,8 @@ void TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
   point.screenPosition.x = mouse_event.globalX;
   point.position.y = mouse_event.y;
   point.screenPosition.y = mouse_event.globalY;
+  point.tiltX = 0;
+  point.tiltY = 0;
 }
 
 bool TouchEmulator::InPinchGestureMode() const {
diff --git a/content/browser/renderer_host/input/touch_event_queue.cc b/content/browser/renderer_host/input/touch_event_queue.cc
index 9de8093..8f3a6a9 100644
--- a/content/browser/renderer_host/input/touch_event_queue.cc
+++ b/content/browser/renderer_host/input/touch_event_queue.cc
@@ -56,7 +56,9 @@ bool HasPointChanged(const WebTouchPoint& point_1,
       point_1.radiusX != point_2.radiusX ||
       point_1.radiusY != point_2.radiusY ||
       point_1.rotationAngle != point_2.rotationAngle ||
-      point_1.force != point_2.force) {
+      point_1.force != point_2.force ||
+      point_1.tiltX != point_2.tiltX ||
+      point_1.tiltY != point_2.tiltY) {
     return true;
   }
   return false;
diff --git a/content/browser/renderer_host/input/web_input_event_util_unittest.cc b/content/browser/renderer_host/input/web_input_event_util_unittest.cc
index 862d6c1..439e2c1 100644
--- a/content/browser/renderer_host/input/web_input_event_util_unittest.cc
+++ b/content/browser/renderer_host/input/web_input_event_util_unittest.cc
@@ -28,6 +28,10 @@ using ui::MotionEventGeneric;
 namespace content {
 
 TEST(WebInputEventUtilTest, MotionEventConversion) {
+
+  const MotionEvent::ToolType tool_types[] = {MotionEvent::TOOL_TYPE_FINGER,
+                                              MotionEvent::TOOL_TYPE_STYLUS,
+                                              MotionEvent::TOOL_TYPE_MOUSE};
   ui::PointerProperties pointer(5, 10, 40);
   pointer.id = 15;
   pointer.raw_x = 20;
@@ -35,34 +39,45 @@ TEST(WebInputEventUtilTest, MotionEventConversion) {
   pointer.pressure = 30;
   pointer.touch_minor = 35;
   pointer.orientation = static_cast<float>(-M_PI / 2);
-  MotionEventGeneric event(
-      MotionEvent::ACTION_DOWN, base::TimeTicks::Now(), pointer);
-  event.set_flags(ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
-  event.set_unique_event_id(123456U);
+  pointer.tilt = static_cast<float>(-M_PI / 3);
+  for (MotionEvent::ToolType tool_type : tool_types) {
+    pointer.tool_type = tool_type;
+    MotionEventGeneric event(
+        MotionEvent::ACTION_DOWN, base::TimeTicks::Now(), pointer);
+    event.set_flags(ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
+    event.set_unique_event_id(123456U);
 
-  WebTouchEvent expected_event;
-  expected_event.type = WebInputEvent::TouchStart;
-  expected_event.touchesLength = 1;
-  expected_event.timeStampSeconds =
-      (event.GetEventTime() - base::TimeTicks()).InSecondsF();
-  expected_event.modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
-  WebTouchPoint expected_pointer;
-  expected_pointer.id = pointer.id;
-  expected_pointer.state = WebTouchPoint::StatePressed;
-  expected_pointer.position = blink::WebFloatPoint(pointer.x, pointer.y);
-  expected_pointer.screenPosition =
-      blink::WebFloatPoint(pointer.raw_x, pointer.raw_y);
-  expected_pointer.radiusX = pointer.touch_major / 2.f;
-  expected_pointer.radiusY = pointer.touch_minor / 2.f;
-  expected_pointer.rotationAngle = 0.f;
-  expected_pointer.force = pointer.pressure;
-  expected_event.touches[0] = expected_pointer;
-  expected_event.uniqueTouchEventId = 123456U;
+    WebTouchEvent expected_event;
+    expected_event.type = WebInputEvent::TouchStart;
+    expected_event.touchesLength = 1;
+    expected_event.timeStampSeconds =
+        (event.GetEventTime() - base::TimeTicks()).InSecondsF();
+    expected_event.modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
+    WebTouchPoint expected_pointer;
+    expected_pointer.id = pointer.id;
+    expected_pointer.state = WebTouchPoint::StatePressed;
+    expected_pointer.position = blink::WebFloatPoint(pointer.x, pointer.y);
+    expected_pointer.screenPosition =
+        blink::WebFloatPoint(pointer.raw_x, pointer.raw_y);
+    expected_pointer.radiusX = pointer.touch_major / 2.f;
+    expected_pointer.radiusY = pointer.touch_minor / 2.f;
+    expected_pointer.rotationAngle = 0.f;
+    expected_pointer.force = pointer.pressure;
+    if (tool_type == MotionEvent::TOOL_TYPE_STYLUS) {
+      expected_pointer.tiltX = -60;
+      expected_pointer.tiltY = 0;
+    } else {
+      expected_pointer.tiltX = 0;
+      expected_pointer.tiltY = 0;
+    }
+    expected_event.touches[0] = expected_pointer;
+    expected_event.uniqueTouchEventId = 123456U;
 
-  WebTouchEvent actual_event =
-      ui::CreateWebTouchEventFromMotionEvent(event, false);
-  EXPECT_EQ(WebInputEventTraits::ToString(expected_event),
-            WebInputEventTraits::ToString(actual_event));
+    WebTouchEvent actual_event =
+        ui::CreateWebTouchEventFromMotionEvent(event, false);
+    EXPECT_EQ(WebInputEventTraits::ToString(expected_event),
+              WebInputEventTraits::ToString(actual_event));
+  }
 }
 
 TEST(WebInputEventUtilTest, ScrollUpdateConversion) {