Fold |is_touch_handle_event| into MotionEventAndroid

Polished up the plumbing by removing the only extra parameter
passed along. This consolidates the overloaded methods
|OnTouchEvent| in RWHVA.

Change-Id: I9e3db0c4c02dbd8e696b681c4fad3f9fd543e9d8
Reviewed-on: https://chromium-review.googlesource.com/612033
Commit-Queue: Jinsuk Kim <[email protected]>
Reviewed-by: Pedro Amaral <[email protected]>
Reviewed-by: Alexandre Elias <[email protected]>
Reviewed-by: Bo <[email protected]>
Cr-Commit-Position: refs/heads/master@{#498352}
diff --git a/ui/android/event_forwarder.cc b/ui/android/event_forwarder.cc
index 4fdd3c894..023bc6e 100644
--- a/ui/android/event_forwarder.cc
+++ b/ui/android/event_forwarder.cc
@@ -67,7 +67,7 @@
                                       jint android_tool_type_1,
                                       jint android_button_state,
                                       jint android_meta_state,
-                                      jboolean is_touch_handle_event) {
+                                      jboolean for_touch_handle) {
   ui::MotionEventAndroid::Pointer pointer0(
       pointer_id_0, pos_x_0, pos_y_0, touch_major_0, touch_minor_0,
       orientation_0, tilt_0, android_tool_type_0);
@@ -78,8 +78,9 @@
       env, motion_event.obj(), 1.f / view_->GetDipScale(), 0.f, 0.f, 0.f,
       time_ms, android_action, pointer_count, history_size, action_index,
       0 /* action_button */, android_button_state, android_meta_state,
-      raw_pos_x - pos_x_0, raw_pos_y - pos_y_0, &pointer0, &pointer1);
-  return view_->OnTouchEvent(event, is_touch_handle_event);
+      raw_pos_x - pos_x_0, raw_pos_y - pos_y_0, for_touch_handle, &pointer0,
+      &pointer1);
+  return view_->OnTouchEvent(event);
 }
 
 void EventForwarder::OnMouseEvent(JNIEnv* env,
@@ -107,7 +108,8 @@
       time_ms, android_action, 1 /* pointer_count */, 0 /* history_size */,
       0 /* action_index */, android_action_button, android_button_state,
       android_meta_state, 0 /* raw_offset_x_pixels */,
-      0 /* raw_offset_y_pixels */, &pointer, nullptr);
+      0 /* raw_offset_y_pixels */, false /* for_touch_handle */, &pointer,
+      nullptr);
   view_->OnMouseEvent(event);
 }
 
@@ -131,12 +133,12 @@
                               delta.InMicroseconds(), 1, 1000000, 50);
   ui::MotionEventAndroid::Pointer pointer(
       0, x, y, 0.0f /* touch_major */, 0.0f /* touch_minor */, 0.0f, 0.0f, 0);
-  ui::MotionEventAndroid event(env, nullptr, 1.f / view_->GetDipScale(),
-                               ticks_x, ticks_y, pixels_per_tick, time_ms,
-                               0 /* action */, 1 /* pointer_count */,
-                               0 /* history_size */, 0 /* action_index */, 0, 0,
-                               0, 0 /* raw_offset_x_pixels */,
-                               0 /* raw_offset_y_pixels */, &pointer, nullptr);
+  ui::MotionEventAndroid event(
+      env, nullptr, 1.f / view_->GetDipScale(), ticks_x, ticks_y,
+      pixels_per_tick, time_ms, 0 /* action */, 1 /* pointer_count */,
+      0 /* history_size */, 0 /* action_index */, 0, 0, 0,
+      0 /* raw_offset_x_pixels */, 0 /* raw_offset_y_pixels */,
+      false /* for_touch_handle */, &pointer, nullptr);
 
   view_->OnMouseWheelEvent(event);
 }
diff --git a/ui/android/view_android.cc b/ui/android/view_android.cc
index 91b31f9..915e09a7 100644
--- a/ui/android/view_android.cc
+++ b/ui/android/view_android.cc
@@ -403,20 +403,17 @@
   return client->OnDragEvent(*e);
 }
 
-bool ViewAndroid::OnTouchEvent(const MotionEventAndroid& event,
-                               bool for_touch_handle) {
-  return HitTest(
-      base::Bind(&ViewAndroid::SendTouchEventToClient, for_touch_handle), event,
-      event.GetPoint());
+bool ViewAndroid::OnTouchEvent(const MotionEventAndroid& event) {
+  return HitTest(base::Bind(&ViewAndroid::SendTouchEventToClient), event,
+                 event.GetPoint());
 }
 
 // static
-bool ViewAndroid::SendTouchEventToClient(bool for_touch_handle,
-                                         ViewClient* client,
+bool ViewAndroid::SendTouchEventToClient(ViewClient* client,
                                          const MotionEventAndroid& event,
                                          const gfx::PointF& point) {
   std::unique_ptr<MotionEventAndroid> e(event.CreateFor(point));
-  return client->OnTouchEvent(*e, for_touch_handle);
+  return client->OnTouchEvent(*e);
 }
 
 bool ViewAndroid::OnMouseEvent(const MotionEventAndroid& event) {
diff --git a/ui/android/view_android.h b/ui/android/view_android.h
index 577c313d..df1c438 100644
--- a/ui/android/view_android.h
+++ b/ui/android/view_android.h
@@ -189,7 +189,7 @@
   friend class ViewAndroidBoundsTest;
 
   bool OnDragEvent(const DragEventAndroid& event);
-  bool OnTouchEvent(const MotionEventAndroid& event, bool for_touch_handle);
+  bool OnTouchEvent(const MotionEventAndroid& event);
   bool OnMouseEvent(const MotionEventAndroid& event);
   bool OnMouseWheelEvent(const MotionEventAndroid& event);
 
@@ -210,8 +210,7 @@
   static bool SendDragEventToClient(ViewClient* client,
                                     const DragEventAndroid& event,
                                     const gfx::PointF& point);
-  static bool SendTouchEventToClient(bool for_touch_handle,
-                                     ViewClient* client,
+  static bool SendTouchEventToClient(ViewClient* client,
                                      const MotionEventAndroid& event,
                                      const gfx::PointF& point);
   static bool SendMouseEventToClient(ViewClient* client,
diff --git a/ui/android/view_android_unittests.cc b/ui/android/view_android_unittests.cc
index f3d077a..2205668 100644
--- a/ui/android/view_android_unittests.cc
+++ b/ui/android/view_android_unittests.cc
@@ -20,8 +20,7 @@
   TestViewClient() : handle_event_(true), called_(false) {}
 
   void SetHandleEvent(bool handle_event) { handle_event_ = handle_event; }
-  bool OnTouchEvent(const MotionEventAndroid& event,
-                    bool for_touch_handle) override {
+  bool OnTouchEvent(const MotionEventAndroid& event) override {
     called_ = true;
     return handle_event_;
   }
@@ -56,9 +55,9 @@
     ui::MotionEventAndroid::Pointer pointer0(0, x, y, 0, 0, 0, 0, 0);
     ui::MotionEventAndroid::Pointer pointer1(0, 0, 0, 0, 0, 0, 0, 0);
     ui::MotionEventAndroid event(nullptr, JavaParamRef<jobject>(nullptr), 1.f,
-                                 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+                                 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, false,
                                  &pointer0, &pointer1);
-    root_.OnTouchEvent(event, false);
+    root_.OnTouchEvent(event);
   }
 
   void ExpectHit(const TestViewClient& hitClient) {
diff --git a/ui/android/view_client.cc b/ui/android/view_client.cc
index 2fc2532f..007ff62d 100644
--- a/ui/android/view_client.cc
+++ b/ui/android/view_client.cc
@@ -6,8 +6,7 @@
 
 namespace ui {
 
-bool ViewClient::OnTouchEvent(const MotionEventAndroid& event,
-                              bool for_touch_handle) {
+bool ViewClient::OnTouchEvent(const MotionEventAndroid& event) {
   return false;
 }
 
diff --git a/ui/android/view_client.h b/ui/android/view_client.h
index 95bbc28..6a01dff1 100644
--- a/ui/android/view_client.h
+++ b/ui/android/view_client.h
@@ -19,8 +19,7 @@
 // the processing.
 class UI_ANDROID_EXPORT ViewClient {
  public:
-  virtual bool OnTouchEvent(const MotionEventAndroid& event,
-                            bool for_touch_handle);
+  virtual bool OnTouchEvent(const MotionEventAndroid& event);
   virtual bool OnMouseEvent(const MotionEventAndroid& event);
   virtual bool OnMouseWheelEvent(const MotionEventAndroid& event);
   virtual bool OnDragEvent(const DragEventAndroid& event);
diff --git a/ui/events/android/motion_event_android.cc b/ui/events/android/motion_event_android.cc
index 4d458420..09f030db 100644
--- a/ui/events/android/motion_event_android.cc
+++ b/ui/events/android/motion_event_android.cc
@@ -209,6 +209,7 @@
                                        jint android_meta_state,
                                        jfloat raw_offset_x_pixels,
                                        jfloat raw_offset_y_pixels,
+                                       jboolean for_touch_handle,
                                        const Pointer* const pointer0,
                                        const Pointer* const pointer1)
     : pix_to_dip_(pix_to_dip),
@@ -216,6 +217,7 @@
       ticks_y_(ticks_y),
       tick_multiplier_(tick_multiplier),
       time_sec_(time_ms / 1000),
+      for_touch_handle_(for_touch_handle),
       cached_time_(FromAndroidTime(time_ms)),
       cached_action_(FromAndroidAction(android_action)),
       cached_pointer_count_(pointer_count),
@@ -246,6 +248,7 @@
       ticks_y_(e.ticks_y_),
       tick_multiplier_(e.tick_multiplier_),
       time_sec_(e.time_sec_),
+      for_touch_handle_(e.for_touch_handle_),
       cached_time_(e.cached_time_),
       cached_action_(e.cached_action_),
       cached_pointer_count_(e.cached_pointer_count_),
@@ -261,6 +264,22 @@
     cached_pointers_[1] = e.cached_pointers_[1];
 }
 
+//  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;
+}
+
 std::unique_ptr<MotionEventAndroid> MotionEventAndroid::CreateFor(
     const gfx::PointF& point) const {
   std::unique_ptr<MotionEventAndroid> event(new MotionEventAndroid(*this));
diff --git a/ui/events/android/motion_event_android.h b/ui/events/android/motion_event_android.h
index a208366a..e23d0e5 100644
--- a/ui/events/android/motion_event_android.h
+++ b/ui/events/android/motion_event_android.h
@@ -25,6 +25,10 @@
 // while all *output* coordinates are in DIPs (as with WebTouchEvent).
 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);
+
   struct Pointer {
     Pointer(jint id,
             jfloat pos_x_pixels,
@@ -64,6 +68,7 @@
                      jint meta_state,
                      jfloat raw_offset_x_pixels,
                      jfloat raw_offset_y_pixels,
+                     jboolean for_touch_handle,
                      const Pointer* const pointer0,
                      const Pointer* const pointer1);
   ~MotionEventAndroid() override;
@@ -110,6 +115,7 @@
   float ticks_y() const { return ticks_y_; }
   float time_sec() const { return time_sec_; }
   float GetTickMultiplier() const;
+  bool for_touch_handle() const { return for_touch_handle_; }
 
   base::android::ScopedJavaLocalRef<jobject> GetJavaObject() const;
 
@@ -139,6 +145,8 @@
   const float tick_multiplier_;
   const uint64_t time_sec_;
 
+  const bool for_touch_handle_;
+
   const base::TimeTicks cached_time_;
   const Action cached_action_;
   const size_t cached_pointer_count_;
diff --git a/ui/events/android/motion_event_android_unittest.cc b/ui/events/android/motion_event_android_unittest.cc
index 8c67a9d..e71b5790 100644
--- a/ui/events/android/motion_event_android_unittest.cc
+++ b/ui/events/android/motion_event_android_unittest.cc
@@ -66,7 +66,7 @@
       base::android::AttachCurrentThread(), nullptr, kPixToDip, 0.f, 0.f, 0.f,
       event_time_ms, kAndroidActionDown, pointer_count, history_size,
       action_index, kAndroidActionButton, kAndroidButtonPrimary,
-      kAndroidAltKeyDown, raw_offset, -raw_offset, &p0, &p1);
+      kAndroidAltKeyDown, raw_offset, -raw_offset, false, &p0, &p1);
 
   EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
   EXPECT_EQ(event_time, event.GetEventTime());
@@ -106,7 +106,8 @@
       1, 13.7f, -7.13f, 5.3f, 1.2f, 0.1f, 0.2f, kAndroidToolTypeFinger);
   MotionEventAndroid event(base::android::AttachCurrentThread(), nullptr,
                            kPixToDip, 0, 0, 0, 0, kAndroidActionDown,
-                           pointer_count, 0, 0, 0, 0, 0, 0, 0, &p0, nullptr);
+                           pointer_count, 0, 0, 0, 0, 0, 0, 0, false, &p0,
+                           nullptr);
 
   std::unique_ptr<MotionEvent> clone = event.Clone();
   EXPECT_EQ(ui::test::ToString(event), ui::test::ToString(*clone));
@@ -120,7 +121,7 @@
   MotionEventAndroid event(base::android::AttachCurrentThread(), nullptr,
                            kPixToDip, 0, 0, 0, event_time_ms,
                            kAndroidActionDown, pointer_count, 0, 0, 0, 0, 0, 0,
-                           0, &p0, nullptr);
+                           0, false, &p0, nullptr);
 
   std::unique_ptr<MotionEvent> cancel_event = event.Cancel();
   EXPECT_EQ(MotionEvent::ACTION_CANCEL, cancel_event->GetAction());
@@ -142,7 +143,7 @@
   MotionEventAndroid::Pointer p1(1, 0, 0, 0, 0, orientation1, 0, 0);
   MotionEventAndroid event(base::android::AttachCurrentThread(), nullptr,
                            kPixToDip, 0, 0, 0, 0, kAndroidActionDown,
-                           pointer_count, 0, 0, 0, 0, 0, 0, 0, &p0, &p1);
+                           pointer_count, 0, 0, 0, 0, 0, 0, 0, false, &p0, &p1);
 
   EXPECT_EQ(0.f, event.GetOrientation(0));
   EXPECT_EQ(0.f, event.GetOrientation(1));
@@ -154,8 +155,8 @@
   MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, 0, 0);
   MotionEventAndroid event(base::android::AttachCurrentThread(), nullptr,
                            kPixToDip, 0, 0, 0, 0, kAndroidActionDown,
-                           pointer_count, history_size, 0, 0, 0, 0, 0, 0, &p0,
-                           nullptr);
+                           pointer_count, history_size, 0, 0, 0, 0, 0, 0, false,
+                           &p0, nullptr);
 
   EXPECT_EQ(0U, event.GetHistorySize());
 }
@@ -171,7 +172,7 @@
   MotionEventAndroid event(base::android::AttachCurrentThread(), nullptr,
                            kPixToDip, 0, 0, 0, 0, kAndroidActionPointerDown,
                            pointer_count, history_size, action_index, 0, 0, 0,
-                           0, 0, &p0, &p1);
+                           0, 0, false, &p0, &p1);
 
   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, event.GetAction());
   EXPECT_EQ(action_index, event.GetActionIndex());