Remove WebTouchEvent from TouchEventManager APIs

third_party/WebKit/Source/core/input/TouchEventManager.cpp

 // Copyright 2016 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.
 
 #include "core/input/TouchEventManager.h"
 
 #include <memory>
 #include "core/dom/Document.h"
 #include "core/events/TouchEvent.h"
 #include "core/frame/Deprecation.h"
@@ skipping 43 matching lines @@
       return g_empty_atom;
   }
 }
 
 enum TouchEventDispatchResultType {
   kUnhandledTouches,  // Unhandled touch events.
   kHandledTouches,    // Handled touch events.
   kTouchEventDispatchResultTypeMax,
 };
 
-bool IsTouchSequenceStart(const WebTouchEvent& event) {
-  if (!event.touches_length)
+bool IsTouchSequenceStart(const Vector<WebCoalescedPointerEvent>& event) {
+  if (!event.size())
     return false;
-  if (event.GetType() != WebInputEvent::kTouchStart)
-    return false;
-  for (size_t i = 0; i < event.touches_length; ++i) {
-    if (event.touches[i].state != blink::WebTouchPoint::kStatePressed)
+  for (size_t i = 0; i < event.size(); ++i) {
+    if (event[i].first.action !=
+        WebPointerProperties::PointerAction::kPointerDown)
       return false;
   }
   return true;
 }
 
 // Defining this class type local to dispatchTouchEvents() and annotating
 // it with STACK_ALLOCATED(), runs into MSVC(VS 2013)'s C4822 warning
 // that the local class doesn't provide a local definition for 'operator new'.
 // Which it intentionally doesn't and shouldn't.
 //
@@ skipping 29 matching lines @@
   current_touch_action_ = kTouchActionAuto;
 }
 
 DEFINE_TRACE(TouchEventManager) {
   visitor->Trace(frame_);
   visitor->Trace(touch_sequence_document_);
   visitor->Trace(target_for_touch_id_);
 }
 
 WebInputEventResult TouchEventManager::DispatchTouchEvents(
-    const WebTouchEvent& event,
+    const Vector<WebCoalescedPointerEvent>& event,
     const HeapVector<TouchInfo>& touch_infos,
     bool all_touches_released) {
   // Build up the lists to use for the |touches|, |targetTouches| and
   // |changedTouches| attributes in the JS event. See
   // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
   // lists fit together.
 
-  if (event.GetType() == WebInputEvent::kTouchEnd ||
-      event.GetType() == WebInputEvent::kTouchCancel ||
-      event.touches_length > 1) {
+  if (event.size() > 1 ||
+      event[0].first.action ==
+          WebPointerProperties::PointerAction::kPointerUp ||
+      event[0].first.action ==
+          WebPointerProperties::PointerAction::kPointerCancel) {
     suppressing_touchmoves_within_slop_ = false;
   }
 
   if (suppressing_touchmoves_within_slop_ &&
-      event.GetType() == WebInputEvent::kTouchMove) {
-    if (!event.moved_beyond_slop_region)
+      event[0].first.action ==
+          WebPointerProperties::PointerAction::kPointerMove) {
+    if (!event[0].first.moved_beyond_slop_region)
       return WebInputEventResult::kHandledSuppressed;
     suppressing_touchmoves_within_slop_ = false;
   }
 
   // Holds the complete set of touches on the screen.
   TouchList* touches = TouchList::Create();
 
   // A different view on the 'touches' list above, filtered and grouped by
   // event target. Used for the |targetTouches| list in the JS event.
   using TargetTouchesHeapMap = HeapHashMap<EventTarget*, Member<TouchList>>;
@@ skipping 48 matching lines @@
     }
   }
 
   if (all_touches_released) {
     touch_sequence_document_.Clear();
     current_touch_action_ = kTouchActionAuto;
   }
 
   WebInputEventResult event_result = WebInputEventResult::kNotHandled;
 
+  // Only for setting it inside TouchEvent for compatibility.
+  WebTouchEvent web_touch_event;
+  for (size_t i = 0; i < event.size(); i++) {
+    const auto& touch_pointer_event = event[0].first;
+    WebTouchPoint touch_point;
+    // WebPointerProperties attributes
+    touch_point.id = touch_pointer_event.id;
+    touch_point.force = touch_pointer_event.force;
+    touch_point.tilt_x = touch_pointer_event.tilt_x;
+    touch_point.tilt_y = touch_pointer_event.tilt_y;
+    touch_point.tangential_pressure = touch_pointer_event.tangential_pressure;
+    touch_point.twist = touch_pointer_event.twist;
+    touch_point.button = touch_pointer_event.button;
+    touch_point.pointer_type = touch_pointer_event.pointer_type;
+    touch_point.movement_x = touch_pointer_event.movement_x;
+    touch_point.movement_y = touch_pointer_event.movement_y;
+    // WebTouchPoint attributes
+    touch_point.rotation_angle = touch_pointer_event.rotation_angle;
+
+    web_touch_event.touches[web_touch_event.touches_length++] = touch_point;
+  }
+  // WebInutEvent attributes
+  web_touch_event.SetFrameScale(event[0].first.FrameScale());
+  web_touch_event.SetFrameTranslate(event[0].first.FrameTranslate());
+  web_touch_event.SetTimeStampSeconds(event[0].first.TimeStampSeconds());
+  web_touch_event.SetType(event[0].first.GetType());
+  web_touch_event.SetModifiers(event[0].first.GetModifiers());
+  // WebTouchEvent attributes
+  web_touch_event.dispatch_type = event[0].first.dispatch_type;
+  web_touch_event.moved_beyond_slop_region =
+      event[0].first.moved_beyond_slop_region;
+  web_touch_event.touch_start_or_first_touch_move =
+      event[0].first.touch_start_or_first_touch_move;
+
   // Now iterate through the |changedTouches| list and |m_targets| within it,
   // sending TouchEvents to the targets as required.
   for (unsigned state = 0; state <= WebTouchPoint::kStateMax; ++state) {
     if (!changed_touches[state].touches_)
       continue;
 
     const AtomicString& event_name(TouchEventNameForTouchPointState(
         static_cast<WebTouchPoint::State>(state)));
+
     for (const auto& event_target : changed_touches[state].targets_) {
       EventTarget* touch_event_target = event_target;
       TouchEvent* touch_event = TouchEvent::Create(
-          event, touches, touches_by_target.at(touch_event_target),
+          web_touch_event, touches, touches_by_target.at(touch_event_target),
           changed_touches[state].touches_.Get(), event_name,
           touch_event_target->ToNode()->GetDocument().domWindow(),
           current_touch_action_);
 
       DispatchEventResult dom_dispatch_result =
           touch_event_target->DispatchEvent(touch_event);
 
       // Only report for top level documents with a single touch on
       // touch-start or the first touch-move.
-      if (event.touch_start_or_first_touch_move && touch_infos.size() == 1 &&
+      if (touch_infos.size() == 1 &&
+          event[0].first.touch_start_or_first_touch_move &&
           frame_->IsMainFrame()) {
         // Record the disposition and latency of touch starts and first touch
         // moves before and after the page is fully loaded respectively.
         int64_t latency_in_micros =
             (TimeTicks::Now() -
-             TimeTicks::FromSeconds(event.TimeStampSeconds()))
+             TimeTicks::FromSeconds(event[0].first.TimeStampSeconds()))
                 .InMicroseconds();
-        if (event.IsCancelable()) {
+        if (event[0].first.IsCancelable()) {
           if (frame_->GetDocument()->IsLoadCompleted()) {
             DEFINE_STATIC_LOCAL(EnumerationHistogram,
                                 touch_dispositions_after_page_load_histogram,
                                 ("Event.Touch.TouchDispositionsAfterPageLoad",
                                  kTouchEventDispatchResultTypeMax));
             touch_dispositions_after_page_load_histogram.Count(
                 (dom_dispatch_result != DispatchEventResult::kNotCanceled)
                     ? kHandledTouches
                     : kUnhandledTouches);
 
@@ skipping 21 matching lines @@
                               touch_dispositions_outside_fling_histogram,
                               ("Event.Touch.TouchDispositionsOutsideFling2",
                                kTouchEventDispatchResultTypeMax));
           touch_dispositions_outside_fling_histogram.Count(
               (dom_dispatch_result != DispatchEventResult::kNotCanceled)
                   ? kHandledTouches
                   : kUnhandledTouches);
         }
 
         // Report the touch disposition when there is an active fling animation.
-        if (event.dispatch_type ==
+        if (event[0].first.dispatch_type ==
             WebInputEvent::kListenersForcedNonBlockingDueToFling) {
           DEFINE_STATIC_LOCAL(EnumerationHistogram,
                               touch_dispositions_during_fling_histogram,
                               ("Event.Touch.TouchDispositionsDuringFling2",
                                kTouchEventDispatchResultTypeMax));
           touch_dispositions_during_fling_histogram.Count(
               touch_event->PreventDefaultCalledOnUncancelableEvent()
                   ? kHandledTouches
                   : kUnhandledTouches);
         }
@@ skipping 156 matching lines @@
     touch_info.content_point = page_point.ScaledBy(scale_factor);
     touch_info.adjusted_radius =
         FloatSize(touch_info.point.radius_x, touch_info.point.radius_y)
             .ScaledBy(scale_factor);
     touch_info.known_target = known_target;
     touch_info.region = region_id;
   }
 }
 
 bool TouchEventManager::ReHitTestTouchPointsIfNeeded(
-    const WebTouchEvent& event,
+    const Vector<WebCoalescedPointerEvent>& event,
     HeapVector<TouchInfo>& touch_infos) {
   bool new_touch_sequence = true;
   bool all_touches_released = true;
 
-  for (unsigned i = 0; i < event.touches_length; ++i) {
-    WebTouchPoint::State state = event.touches[i].state;
-    if (state != WebTouchPoint::kStatePressed)
+  for (size_t i = 0; i < event.size(); ++i) {
+    WebPointerProperties::PointerAction action = event[i].first.action;
+    if (action != WebPointerProperties::PointerAction::kPointerDown)
       new_touch_sequence = false;
-    if (state != WebTouchPoint::kStateReleased &&
-        state != WebTouchPoint::kStateCancelled)
+    if (action != WebPointerProperties::PointerAction::kPointerUp &&
+        action != WebPointerProperties::PointerAction::kPointerCancel)
       all_touches_released = false;
   }
   if (new_touch_sequence) {
     // Ideally we'd ASSERT(!m_touchSequenceDocument) here since we should
     // have cleared the active document when we saw the last release. But we
     // have some tests that violate this, ClusterFuzz could trigger it, and
     // there may be cases where the browser doesn't reliably release all
     // touches. http://crbug.com/345372 tracks this.
     touch_sequence_document_.Clear();
   }
@@ skipping 23 matching lines @@
     }
     return false;
   }
 
   SetAllPropertiesOfTouchInfos(touch_infos);
 
   return true;
 }
 
 WebInputEventResult TouchEventManager::HandleTouchEvent(
-    const WebTouchEvent& event,
+    const Vector<WebCoalescedPointerEvent>& event,
     HeapVector<TouchInfo>& touch_infos) {
   if (!ReHitTestTouchPointsIfNeeded(event, touch_infos))
     return WebInputEventResult::kNotHandled;
 
   bool all_touches_released = true;
-  for (unsigned i = 0; i < event.touches_length; ++i) {
-    WebTouchPoint::State state = event.touches[i].state;
-    if (state != WebTouchPoint::kStateReleased &&
-        state != WebTouchPoint::kStateCancelled)
+  for (size_t i = 0; i < event.size(); ++i) {
+    WebPointerProperties::PointerAction action = event[i].first.action;
+    if (action != WebPointerProperties::PointerAction::kPointerUp &&
+        action != WebPointerProperties::PointerAction::kPointerCancel)
       all_touches_released = false;
   }
 
   return DispatchTouchEvents(event, touch_infos, all_touches_released);
 }
 
 bool TouchEventManager::IsAnyTouchActive() const {
   return touch_pressed_;
 }
 
 }  // namespace blink