BASELINE: Update Chromium to 66.0.3359.156

Change-Id: I0c9831ad39911a086b6377b16f995ad75a51e441
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

5 files changed, 149 insertions, 54 deletions

diff --git a/chromium/ui/events/android/gesture_event_android.cc b/chromium/ui/events/android/gesture_event_android.cc
index d0f25354b3d..277efb57479 100644
--- a/chromium/ui/events/android/gesture_event_android.cc
+++ b/chromium/ui/events/android/gesture_event_android.cc
@@ -12,12 +12,24 @@ GestureEventAndroid::GestureEventAndroid(int type,
                                          const gfx::PointF& location,
                                          const gfx::PointF& screen_location,
                                          long time_ms,
-                                         float delta)
+                                         float scale,
+                                         float delta_x,
+                                         float delta_y,
+                                         float velocity_x,
+                                         float velocity_y,
+                                         bool target_viewport,
+                                         bool synthetic_scroll)
     : type_(type),
       location_(location),
       screen_location_(screen_location),
       time_ms_(time_ms),
-      delta_(delta) {}
+      scale_(scale),
+      delta_x_(delta_x),
+      delta_y_(delta_y),
+      velocity_x_(velocity_x),
+      velocity_y_(velocity_y),
+      target_viewport_(target_viewport),
+      synthetic_scroll_(synthetic_scroll) {}
 
 GestureEventAndroid::~GestureEventAndroid() {}
 
@@ -26,7 +38,8 @@ std::unique_ptr<GestureEventAndroid> GestureEventAndroid::CreateFor(
   auto offset = new_location - location_;
   gfx::PointF new_screen_location = screen_location_ + offset;
   return std::unique_ptr<GestureEventAndroid>(new GestureEventAndroid(
-      type_, new_location, new_screen_location, time_ms_, delta_));
+      type_, new_location, new_screen_location, time_ms_, scale_, delta_x_,
+      delta_y_, velocity_x_, velocity_y_, target_viewport_, synthetic_scroll_));
 }
 
 }  // namespace ui
diff --git a/chromium/ui/events/android/gesture_event_android.h b/chromium/ui/events/android/gesture_event_android.h
index d07f343ff2c..2824847a103 100644
--- a/chromium/ui/events/android/gesture_event_android.h
+++ b/chromium/ui/events/android/gesture_event_android.h
@@ -21,7 +21,13 @@ class EVENTS_EXPORT GestureEventAndroid {
                       const gfx::PointF& location,
                       const gfx::PointF& screen_location,
                       long time_ms,
-                      float delta);
+                      float scale,
+                      float delta_x,
+                      float delta_y,
+                      float velocity_x,
+                      float velocity_y,
+                      bool target_viewport,
+                      bool synthetic_scroll);
 
   ~GestureEventAndroid();
 
@@ -29,7 +35,13 @@ class EVENTS_EXPORT GestureEventAndroid {
   const gfx::PointF& location() const { return location_; }
   const gfx::PointF& screen_location() const { return screen_location_; }
   long time() const { return time_ms_; }
-  float delta() const { return delta_; }
+  float scale() const { return scale_; }
+  float delta_x() const { return delta_x_; }
+  float delta_y() const { return delta_y_; }
+  float velocity_x() const { return velocity_x_; }
+  float velocity_y() const { return velocity_y_; }
+  bool target_viewport() const { return target_viewport_; }
+  bool synthetic_scroll() const { return synthetic_scroll_; }
 
   // Creates a new GestureEventAndroid instance different from |this| only by
   // its location.
@@ -42,7 +54,13 @@ class EVENTS_EXPORT GestureEventAndroid {
   gfx::PointF screen_location_;
   long time_ms_;
 
-  float delta_;
+  float scale_;
+  float delta_x_;
+  float delta_y_;
+  float velocity_x_;
+  float velocity_y_;
+  bool target_viewport_;
+  bool synthetic_scroll_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventAndroid);
 };
diff --git a/chromium/ui/events/android/motion_event_android.cc b/chromium/ui/events/android/motion_event_android.cc
index 433ff446825..a6ad292d344 100644
--- a/chromium/ui/events/android/motion_event_android.cc
+++ b/chromium/ui/events/android/motion_event_android.cc
@@ -20,43 +20,91 @@ using base::android::ScopedJavaLocalRef;
 namespace ui {
 namespace {
 
-#define EVENT_CASE(x)      \
-  case JNI_MotionEvent::x: \
-    return MotionEventAndroid::x
+#define ACTION_CASE(x)              \
+  case JNI_MotionEvent::ACTION_##x: \
+    return MotionEventAndroid::Action::x
+
+#define ACTION_REVERSE_CASE(x)        \
+  case MotionEventAndroid::Action::x: \
+    return JNI_MotionEvent::ACTION_##x
+
+#define TOOL_TYPE_CASE(x)              \
+  case JNI_MotionEvent::TOOL_TYPE_##x: \
+    return MotionEventAndroid::ToolType::x
+
+#define TOOL_TYPE_REVERSE_CASE(x)       \
+  case MotionEventAndroid::ToolType::x: \
+    return JNI_MotionEvent::TOOL_TYPE_##x
 
 MotionEventAndroid::Action FromAndroidAction(int android_action) {
   switch (android_action) {
-    EVENT_CASE(ACTION_DOWN);
-    EVENT_CASE(ACTION_UP);
-    EVENT_CASE(ACTION_MOVE);
-    EVENT_CASE(ACTION_CANCEL);
-    EVENT_CASE(ACTION_POINTER_DOWN);
-    EVENT_CASE(ACTION_POINTER_UP);
-    EVENT_CASE(ACTION_HOVER_ENTER);
-    EVENT_CASE(ACTION_HOVER_EXIT);
-    EVENT_CASE(ACTION_HOVER_MOVE);
-    EVENT_CASE(ACTION_BUTTON_PRESS);
-    EVENT_CASE(ACTION_BUTTON_RELEASE);
+    ACTION_CASE(DOWN);
+    ACTION_CASE(UP);
+    ACTION_CASE(MOVE);
+    ACTION_CASE(CANCEL);
+    ACTION_CASE(POINTER_DOWN);
+    ACTION_CASE(POINTER_UP);
+    ACTION_CASE(HOVER_ENTER);
+    ACTION_CASE(HOVER_EXIT);
+    ACTION_CASE(HOVER_MOVE);
+    ACTION_CASE(BUTTON_PRESS);
+    ACTION_CASE(BUTTON_RELEASE);
     default:
       NOTREACHED() << "Invalid Android MotionEvent action: " << android_action;
   };
-  return MotionEventAndroid::ACTION_CANCEL;
+  return MotionEventAndroid::Action::CANCEL;
+}
+
+int ToAndroidAction(MotionEventAndroid::Action action) {
+  switch (action) {
+    ACTION_REVERSE_CASE(DOWN);
+    ACTION_REVERSE_CASE(UP);
+    ACTION_REVERSE_CASE(MOVE);
+    ACTION_REVERSE_CASE(CANCEL);
+    ACTION_REVERSE_CASE(POINTER_DOWN);
+    ACTION_REVERSE_CASE(POINTER_UP);
+    ACTION_REVERSE_CASE(HOVER_ENTER);
+    ACTION_REVERSE_CASE(HOVER_EXIT);
+    ACTION_REVERSE_CASE(HOVER_MOVE);
+    ACTION_REVERSE_CASE(BUTTON_PRESS);
+    ACTION_REVERSE_CASE(BUTTON_RELEASE);
+    default:
+      NOTREACHED() << "Invalid MotionEvent action: " << action;
+  };
+  return JNI_MotionEvent::ACTION_CANCEL;
 }
 
 MotionEventAndroid::ToolType FromAndroidToolType(int android_tool_type) {
   switch (android_tool_type) {
-    EVENT_CASE(TOOL_TYPE_UNKNOWN);
-    EVENT_CASE(TOOL_TYPE_FINGER);
-    EVENT_CASE(TOOL_TYPE_STYLUS);
-    EVENT_CASE(TOOL_TYPE_MOUSE);
-    EVENT_CASE(TOOL_TYPE_ERASER);
+    TOOL_TYPE_CASE(UNKNOWN);
+    TOOL_TYPE_CASE(FINGER);
+    TOOL_TYPE_CASE(STYLUS);
+    TOOL_TYPE_CASE(MOUSE);
+    TOOL_TYPE_CASE(ERASER);
     default:
       NOTREACHED() << "Invalid Android MotionEvent tool type: "
                    << android_tool_type;
   };
-  return MotionEventAndroid::TOOL_TYPE_UNKNOWN;
+  return MotionEventAndroid::ToolType::UNKNOWN;
+}
+
+int ToAndroidToolType(MotionEventAndroid::ToolType tool_type) {
+  switch (tool_type) {
+    TOOL_TYPE_REVERSE_CASE(UNKNOWN);
+    TOOL_TYPE_REVERSE_CASE(FINGER);
+    TOOL_TYPE_REVERSE_CASE(STYLUS);
+    TOOL_TYPE_REVERSE_CASE(MOUSE);
+    TOOL_TYPE_REVERSE_CASE(ERASER);
+    default:
+      NOTREACHED() << "Invalid MotionEvent tool type: " << tool_type;
+  };
+  return JNI_MotionEvent::TOOL_TYPE_UNKNOWN;
 }
-#undef EVENT_CASE
+
+#undef ACTION_CASE
+#undef ACTION_REVERSE_CASE
+#undef TOOL_TYPE_CASE
+#undef TOOL_TYPE_REVERSE_CASE
 
 int FromAndroidButtonState(int button_state) {
   int result = 0;
@@ -131,11 +179,11 @@ float ToValidFloat(float x) {
 
 size_t ToValidHistorySize(jint history_size, ui::MotionEvent::Action action) {
   DCHECK_GE(history_size, 0);
-  // While the spec states that only ACTION_MOVE events should contain
+  // While the spec states that only Action::MOVE events should contain
   // historical entries, it's possible that an embedder could repurpose an
-  // ACTION_MOVE event into a different kind of event. In that case, the
+  // Action::MOVE event into a different kind of event. In that case, the
   // historical values are meaningless, and should not be exposed.
-  if (action != ui::MotionEvent::ACTION_MOVE)
+  if (action != ui::MotionEvent::Action::MOVE)
     return 0;
   return history_size;
 }
@@ -179,7 +227,7 @@ MotionEventAndroid::CachedPointer::CachedPointer()
       orientation(0),
       tilt_x(0),
       tilt_y(0),
-      tool_type(TOOL_TYPE_UNKNOWN) {}
+      tool_type(ToolType::UNKNOWN) {}
 
 MotionEventAndroid::MotionEventAndroid(JNIEnv* env,
                                        jobject event,
@@ -253,19 +301,12 @@ MotionEventAndroid::MotionEventAndroid(const MotionEventAndroid& e)
 }
 
 //  static
-int MotionEventAndroid::GetAndroidActionForTesting(int action) {
-  int android_action = JNI_MotionEvent::ACTION_CANCEL;
-  switch (action) {
-    case ui::MotionEvent::ACTION_DOWN:
-      android_action = JNI_MotionEvent::ACTION_DOWN;
-      break;
-    case ui::MotionEvent::ACTION_UP:
-      android_action = JNI_MotionEvent::ACTION_UP;
-      break;
-    default:
-      NOTIMPLEMENTED() << "Conversion not supported: " << action;
-  }
-  return android_action;
+int MotionEventAndroid::GetAndroidAction(Action action) {
+  return ToAndroidAction(action);
+}
+
+int MotionEventAndroid::GetAndroidToolType(ToolType tool_type) {
+  return ToAndroidToolType(tool_type);
 }
 
 std::unique_ptr<MotionEventAndroid> MotionEventAndroid::CreateFor(
@@ -305,8 +346,8 @@ ScopedJavaLocalRef<jobject> MotionEventAndroid::GetJavaObject() const {
 }
 
 int MotionEventAndroid::GetActionIndex() const {
-  DCHECK(cached_action_ == MotionEvent::ACTION_POINTER_UP ||
-         cached_action_ == MotionEvent::ACTION_POINTER_DOWN)
+  DCHECK(cached_action_ == MotionEvent::Action::POINTER_UP ||
+         cached_action_ == MotionEvent::Action::POINTER_DOWN)
       << "Invalid action for GetActionIndex(): " << cached_action_;
   DCHECK_GE(cached_action_index_, 0);
   DCHECK_LT(cached_action_index_, static_cast<int>(cached_pointer_count_));
@@ -341,6 +382,22 @@ float MotionEventAndroid::GetY(size_t pointer_index) const {
       AttachCurrentThread(), event_, pointer_index));
 }
 
+float MotionEventAndroid::GetXPix(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, cached_pointer_count_);
+  if (pointer_index < MAX_POINTERS_TO_CACHE)
+    return cached_pointers_[pointer_index].position.x() / pix_to_dip_;
+  return JNI_MotionEvent::Java_MotionEvent_getXF_I(AttachCurrentThread(),
+                                                   event_, pointer_index);
+}
+
+float MotionEventAndroid::GetYPix(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, cached_pointer_count_);
+  if (pointer_index < MAX_POINTERS_TO_CACHE)
+    return cached_pointers_[pointer_index].position.y() / pix_to_dip_;
+  return JNI_MotionEvent::Java_MotionEvent_getYF_I(AttachCurrentThread(),
+                                                   event_, pointer_index);
+}
+
 float MotionEventAndroid::GetRawX(size_t pointer_index) const {
   return GetX(pointer_index) + cached_raw_position_offset_.x();
 }
@@ -380,7 +437,7 @@ float MotionEventAndroid::GetPressure(size_t pointer_index) const {
   // accessed at most once per event instance).
   if (!event_.obj())
     return 0.f;
-  if (cached_action_ == MotionEvent::ACTION_UP)
+  if (cached_action_ == MotionEvent::Action::UP)
     return 0.f;
   return JNI_MotionEvent::Java_MotionEvent_getPressureF_I(
       AttachCurrentThread(), event_, pointer_index);
diff --git a/chromium/ui/events/android/motion_event_android.h b/chromium/ui/events/android/motion_event_android.h
index e23d0e5c0af..53165164f52 100644
--- a/chromium/ui/events/android/motion_event_android.h
+++ b/chromium/ui/events/android/motion_event_android.h
@@ -27,7 +27,8 @@ class EVENTS_EXPORT MotionEventAndroid : public MotionEvent {
  public:
   // Returns the motion event action defined in Java layer for a given
   // MotionEvent::Action.
-  static int GetAndroidActionForTesting(int action);
+  static int GetAndroidAction(Action action);
+  static int GetAndroidToolType(ToolType tool_type);
 
   struct Pointer {
     Pointer(jint id,
@@ -79,6 +80,9 @@ class EVENTS_EXPORT MotionEventAndroid : public MotionEvent {
 
   // Convenience method returning the pointer at index 0.
   gfx::PointF GetPoint() const { return gfx::PointF(GetX(0), GetY(0)); }
+  gfx::PointF GetPointPix() const {
+    return gfx::PointF(GetXPix(0), GetYPix(0));
+  }
 
   // ui::MotionEvent methods.
   uint32_t GetUniqueEventId() const override;
@@ -119,6 +123,9 @@ class EVENTS_EXPORT MotionEventAndroid : public MotionEvent {
 
   base::android::ScopedJavaLocalRef<jobject> GetJavaObject() const;
 
+  float GetXPix(size_t pointer_index) const;
+  float GetYPix(size_t pointer_index) const;
+
  private:
   struct CachedPointer;
 
diff --git a/chromium/ui/events/android/motion_event_android_unittest.cc b/chromium/ui/events/android/motion_event_android_unittest.cc
index 6ca7bb7e749..2a6b1671de9 100644
--- a/chromium/ui/events/android/motion_event_android_unittest.cc
+++ b/chromium/ui/events/android/motion_event_android_unittest.cc
@@ -72,7 +72,7 @@ TEST(MotionEventAndroidTest, Constructor) {
       action_index, kAndroidActionButton, kAndroidButtonPrimary,
       kAndroidAltKeyDown, raw_offset, -raw_offset, false, &p0, &p1);
 
-  EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
+  EXPECT_EQ(MotionEvent::Action::DOWN, event.GetAction());
   EXPECT_EQ(event_time, event.GetEventTime());
   EXPECT_EQ(p0.pos_x_pixels * kPixToDip, event.GetX(0));
   EXPECT_EQ(p0.pos_y_pixels * kPixToDip, event.GetY(0));
@@ -96,8 +96,8 @@ TEST(MotionEventAndroidTest, Constructor) {
               float_error);
   EXPECT_EQ(p0.id, event.GetPointerId(0));
   EXPECT_EQ(p1.id, event.GetPointerId(1));
-  EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(0));
-  EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(1));
+  EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(0));
+  EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(1));
   EXPECT_EQ(MotionEvent::BUTTON_PRIMARY, event.GetButtonState());
   EXPECT_EQ(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON, event.GetFlags());
   EXPECT_EQ(static_cast<size_t>(pointer_count), event.GetPointerCount());
@@ -136,7 +136,7 @@ TEST(MotionEventAndroidTest, Cancel) {
                            0, false, &p0, nullptr);
 
   std::unique_ptr<MotionEvent> cancel_event = event.Cancel();
-  EXPECT_EQ(MotionEvent::ACTION_CANCEL, cancel_event->GetAction());
+  EXPECT_EQ(MotionEvent::Action::CANCEL, cancel_event->GetAction());
   EXPECT_EQ(event_time, cancel_event->GetEventTime());
   EXPECT_EQ(p0.pos_x_pixels * kPixToDip, cancel_event->GetX(0));
   EXPECT_EQ(p0.pos_y_pixels * kPixToDip, cancel_event->GetY(0));
@@ -193,7 +193,7 @@ TEST(MotionEventAndroidTest, ActionIndexForPointerDown) {
                            pointer_count, history_size, action_index, 0, 0, 0,
                            0, 0, false, &p0, &p1);
 
-  EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, event.GetAction());
+  EXPECT_EQ(MotionEvent::Action::POINTER_DOWN, event.GetAction());
   EXPECT_EQ(action_index, event.GetActionIndex());
 }