Support Coalesced Touch in ppapi

third_party/WebKit/Source/core/events/TouchEvent.cpp

 /*
  * Copyright 2008, The Android Open Source Project
  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright
@@ skipping 18 matching lines @@
 #include "core/events/EventDispatcher.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/html/HTMLElement.h"
 #include "core/input/InputDeviceCapabilities.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "platform/Histogram.h"
 #include "platform/bindings/DOMWrapperWorld.h"
 #include "platform/bindings/ScriptState.h"
+#include "public/platform/WebCoalescedInputEvent.h"
 
 namespace blink {
 
 namespace {
 
 // These offsets change indicies into the ListenerHistogram
 // enumeration. The addition of a series of offsets then
 // produces the resulting ListenerHistogram value.
 // TODO(dtapuska): Remove all of these histogram counts once
 // https://crbug.com/599609 is fixed.
@@ skipping 140 matching lines @@
   else
     result += kTouchTargetHistogramNotHandledOffset;
 
   DEFINE_STATIC_LOCAL(EnumerationHistogram, root_document_listener_histogram,
                       ("Event.Touch.TargetAndDispatchResult2",
                        kTouchTargetAndDispatchResultTypeMax));
   root_document_listener_histogram.Count(
       static_cast<TouchTargetAndDispatchResultType>(result));
 }
 
+// Helper function to get WebTouchEvent from WebCoalescedInputEvent.
+const WebTouchEvent* GetWebTouchEvent(const WebCoalescedInputEvent& event) {
+  return static_cast<const WebTouchEvent*>(&event.Event());
+}
 }  // namespace
 
 TouchEvent::TouchEvent()
     : default_prevented_before_current_target_(false),
       current_touch_action_(TouchAction::kTouchActionAuto) {}
 
-TouchEvent::TouchEvent(const WebTouchEvent& event,
+TouchEvent::TouchEvent(const WebCoalescedInputEvent& event,
                        TouchList* touches,
                        TouchList* target_touches,
                        TouchList* changed_touches,
                        const AtomicString& type,
                        AbstractView* view,
                        TouchAction current_touch_action)
     // Pass a sourceCapabilities including the ability to fire touchevents when
     // creating this touchevent, which is always created from input device
     // capabilities from EventHandler.
     : UIEventWithKeyState(
           type,
           true,
-          event.IsCancelable(),
+          GetWebTouchEvent(event)->IsCancelable(),
           view,
           0,
-          static_cast<WebInputEvent::Modifiers>(event.GetModifiers()),
-          TimeTicks::FromSeconds(event.TimeStampSeconds()),
+          static_cast<WebInputEvent::Modifiers>(event.Event().GetModifiers()),
+          TimeTicks::FromSeconds(event.Event().TimeStampSeconds()),
           view ? view->GetInputDeviceCapabilities()->FiresTouchEvents(true)
                : nullptr),
       touches_(touches),
       target_touches_(target_touches),
       changed_touches_(changed_touches),
       default_prevented_before_current_target_(false),
       current_touch_action_(current_touch_action) {
-  native_event_.reset(new WebTouchEvent(event));
+  DCHECK(WebInputEvent::IsTouchEventType(event.Event().GetType()));
+  native_event_.reset(new WebCoalescedInputEvent(event));
 }
 
 TouchEvent::TouchEvent(const AtomicString& type,
                        const TouchEventInit& initializer)
     : UIEventWithKeyState(type, initializer),
       touches_(TouchList::Create(initializer.touches())),
       target_touches_(TouchList::Create(initializer.targetTouches())),
       changed_touches_(TouchList::Create(initializer.changedTouches())),
       current_touch_action_(TouchAction::kTouchActionAuto) {}
 
@@ skipping 19 matching lines @@
     case PassiveMode::kNotPassive:
     case PassiveMode::kNotPassiveDefault:
       if (!cancelable()) {
         if (view() && view()->GetFrame()) {
           UseCounter::Count(
               view()->GetFrame(),
               UseCounter::kUncancelableTouchEventPreventDefaulted);
         }
 
         if (native_event_ &&
-            native_event_->dispatch_type ==
+            GetWebTouchEvent(*native_event_)->dispatch_type ==
                 WebInputEvent::
                     kListenersForcedNonBlockingDueToMainThreadResponsiveness) {
           // Non blocking due to main thread responsiveness.
           if (view() && view()->GetFrame()) {
             UseCounter::Count(
                 view()->GetFrame(),
                 UseCounter::
                     kUncancelableTouchEventDueToMainThreadResponsivenessPreventDefaulted);
           }
           message_source = kInterventionMessageSource;
@@ skipping 50 matching lines @@
         break;
       default:
         break;
     }
   }
 }
 
 bool TouchEvent::IsTouchStartOrFirstTouchMove() const {
   if (!native_event_)
     return false;
-  return native_event_->touch_start_or_first_touch_move;
+  return GetWebTouchEvent(*native_event_)->touch_start_or_first_touch_move;
 }
 
 void TouchEvent::DoneDispatchingEventAtCurrentTarget() {
   // Do not log for non-cancelable events, events that don't block
   // scrolling, have more than one touch point or aren't on the main frame.
   if (!cancelable() || !IsTouchStartOrFirstTouchMove() ||
       !(touches_ && touches_->length() == 1) ||
       !(view() && view()->GetFrame() && view()->GetFrame()->IsMainFrame()))
     return;
 
@@ skipping 26 matching lines @@
   return ToTouchEvent(EventDispatchMediator::GetEvent());
 }
 
 DispatchEventResult TouchEventDispatchMediator::DispatchEvent(
     EventDispatcher& dispatcher) const {
   Event().GetEventPath().AdjustForTouchEvent(Event());
   return dispatcher.Dispatch();
 }
 
 }  // namespace blink