Support Coalesced Touch in ppapi

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"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestCanvasResult.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/Histogram.h"
 #include "platform/wtf/CurrentTime.h"
 #include "platform/wtf/PtrUtil.h"
+#include "public/platform/WebCoalescedInputEvent.h"
 #include "public/platform/WebTouchEvent.h"
 
 namespace blink {
 
 namespace {
 
 bool HasTouchHandlers(const EventHandlerRegistry& registry) {
   return registry.HasEventHandlers(
              EventHandlerRegistry::kTouchStartOrMoveEventBlocking) ||
          registry.HasEventHandlers(
@@ skipping 79 matching lines @@
 }
 
 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<WebTouchEvent>& coalesced_events,
     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) {
@@ skipping 63 matching lines @@
       changed_touches[point_state].pointer_type_ = point.pointer_type;
     }
   }
 
   if (all_touches_released) {
     touch_sequence_document_.Clear();
     current_touch_action_ = TouchAction::kTouchActionAuto;
   }
 
   WebInputEventResult event_result = WebInputEventResult::kNotHandled;
+  // First we construct the webcoalescedinputevent contains all the coalesced
+  // touch event.
+  std::vector<const WebInputEvent*> coalesced_touches;
+  for (size_t i = 0; i < coalesced_events.size(); ++i) {
+    coalesced_touches.push_back(&coalesced_events[i]);
+  }
+  WebCoalescedInputEvent coalesced_event(event, coalesced_touches);
 
   // 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),
+          coalesced_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 &&
@@ skipping 271 matching lines @@
     return false;
   }
 
   SetAllPropertiesOfTouchInfos(touch_infos);
 
   return true;
 }
 
 WebInputEventResult TouchEventManager::HandleTouchEvent(
     const WebTouchEvent& event,
+    const Vector<WebTouchEvent>& coalesced_events,
     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)
       all_touches_released = false;
   }
 
-  return DispatchTouchEvents(event, touch_infos, all_touches_released);
+  return DispatchTouchEvents(event, coalesced_events, touch_infos,
+                             all_touches_released);
 }
 
 bool TouchEventManager::IsAnyTouchActive() const {
   return touch_pressed_;
 }
 
 }  // namespace blink