Bug 970751 Resample touch events. r=mwu,kats. a=kwierso

gfx/thebes/gfxPrefs.h

@@ -197,6 +197,11 @@ private:
 
   // Use vsync events generated by hardware
   DECL_GFX_PREF(Once, "gfx.frameuniformity.hw-vsync",          FrameUniformityHWVsyncEnabled, bool, false);
+  DECL_GFX_PREF(Once, "gfx.touch.resample",                    TouchResampling, bool, false);
+  // These times should be in nanoseconds
+  DECL_GFX_PREF(Once, "gfx.touch.resample.max-predict",        TouchResampleMaxPredict, int32_t, 8000000);
+  DECL_GFX_PREF(Once, "gfx.touch.resample.vsync-adjust",       TouchVsyncSampleAdjust, int32_t, 5000000);
+  DECL_GFX_PREF(Once, "gfx.touch.resample.min-resample",       TouchResampleMinTime, int32_t, 2000000);
 
   DECL_GFX_PREF(Live, "gl.msaa-level",                         MSAALevel, uint32_t, 2);
 

widget/gonk/GeckoTouchDispatcher.cpp

@@ -0,0 +1,451 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sts=2 et sw=2 tw=80: */
+/* Copyright 2014 Mozilla Foundation and Mozilla contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FrameMetrics.h"
+#include "GeckoProfiler.h"
+#include "GeckoTouchDispatcher.h"
+#include "InputData.h"
+#include "base/basictypes.h"
+#include "gfxPrefs.h"
+#include "libui/Input.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/dom/Touch.h"
+#include "nsAppShell.h"
+#include "nsDebug.h"
+#include "nsThreadUtils.h"
+#include "nsWindow.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include <utils/Timers.h>
+
+#define LOG(args...)                                            \
+  __android_log_print(ANDROID_LOG_INFO, "Gonk" , ## args)
+
+// uncomment to print log resample data
+// #define LOG_RESAMPLE_DATA 1
+
+namespace mozilla {
+
+// Amount of time in MS before an input is considered expired.
+static const uint64_t kInputExpirationThresholdMs = 1000;
+static int32_t nanosecToMillisec(int64_t nanosec) { return nanosec / 1000000; }
+
+static StaticRefPtr<GeckoTouchDispatcher> sTouchDispatcher;
+
+GeckoTouchDispatcher::GeckoTouchDispatcher()
+  : mTouchQueueLock("GeckoTouchDispatcher::mTouchQueueLock")
+  , mTouchEventsFiltered(false)
+  , mTouchDownCount(0)
+  , mTouchTimeDiff(0)
+  , mLastTouchTime(0)
+{
+  // Since GeckoTouchDispatcher is initialized when input is initialized
+  // and reads gfxPrefs, it is the first thing to touch gfxPrefs.
+  // The first thing to touch gfxPrefs MUST occur on the main thread and init
+  // the singleton
+  MOZ_ASSERT(sTouchDispatcher == nullptr);
+  MOZ_ASSERT(NS_IsMainThread());
+  gfxPrefs::GetSingleton();
+
+  mEnabledUniformityInfo = gfxPrefs::UniformityInfo();
+  mResamplingEnabled = gfxPrefs::TouchResampling() &&
+                       gfxPrefs::FrameUniformityHWVsyncEnabled();
+  mVsyncAdjust = gfxPrefs::TouchVsyncSampleAdjust();
+  mMaxPredict = gfxPrefs::TouchResampleMaxPredict();
+  mMinResampleTime = gfxPrefs::TouchResampleMinTime();
+  sTouchDispatcher = this;
+}
+
+class DispatchTouchEventsMainThread : public nsRunnable
+{
+public:
+  DispatchTouchEventsMainThread(GeckoTouchDispatcher* aTouchDispatcher,
+                                uint64_t aVsyncTime)
+    : mTouchDispatcher(aTouchDispatcher)
+    , mVsyncTime(aVsyncTime)
+  {
+  }
+
+  NS_IMETHOD Run()
+  {
+    mTouchDispatcher->DispatchTouchMoveEvents(mVsyncTime);
+    return NS_OK;
+  }
+
+private:
+  nsRefPtr<GeckoTouchDispatcher> mTouchDispatcher;
+  uint64_t mVsyncTime;
+};
+
+class DispatchSingleTouchMainThread : public nsRunnable
+{
+public:
+  DispatchSingleTouchMainThread(GeckoTouchDispatcher* aTouchDispatcher,
+                                MultiTouchInput& aTouch)
+    : mTouchDispatcher(aTouchDispatcher)
+    , mTouch(aTouch)
+  {
+  }
+
+  NS_IMETHOD Run()
+  {
+    mTouchDispatcher->DispatchTouchEvent(mTouch);
+    return NS_OK;
+  }
+
+private:
+  nsRefPtr<GeckoTouchDispatcher> mTouchDispatcher;
+  MultiTouchInput mTouch;
+};
+
+// Timestamp is in nanoseconds
+/* static */ bool
+GeckoTouchDispatcher::NotifyVsync(uint64_t aVsyncTimestamp)
+{
+  if (sTouchDispatcher == nullptr) {
+    return false;
+  }
+
+  MOZ_ASSERT(sTouchDispatcher->mResamplingEnabled);
+  bool haveTouchData = false;
+  {
+    MutexAutoLock lock(sTouchDispatcher->mTouchQueueLock);
+    haveTouchData = !sTouchDispatcher->mTouchMoveEvents.empty();
+  }
+
+  if (haveTouchData) {
+    NS_DispatchToMainThread(new DispatchTouchEventsMainThread(sTouchDispatcher, aVsyncTimestamp));
+  }
+
+  return haveTouchData;
+}
+
+// Touch data timestamps are in milliseconds, aEventTime is in nanoseconds
+void
+GeckoTouchDispatcher::NotifyTouch(MultiTouchInput& aData, uint64_t aEventTime)
+{
+  if (mResamplingEnabled) {
+    switch (aData.mType) {
+      case MultiTouchInput::MULTITOUCH_MOVE:
+      {
+        MutexAutoLock lock(mTouchQueueLock);
+        mTouchMoveEvents.push_back(aData);
+        mTouchTimeDiff = aEventTime - mLastTouchTime;
+        mLastTouchTime = aEventTime;
+        return;
+      }
+      default:
+        break;
+    }
+  }
+
+  NS_DispatchToMainThread(new DispatchSingleTouchMainThread(this, aData));
+}
+
+void
+GeckoTouchDispatcher::DispatchTouchMoveEvents(uint64_t aVsyncTime)
+{
+  MultiTouchInput touchMove;
+
+  {
+    MutexAutoLock lock(mTouchQueueLock);
+    if (mTouchMoveEvents.empty()) {
+      return;
+    }
+
+    int touchCount = mTouchMoveEvents.size();
+    // Both aVsynctime and mLastTouchTime are uint64_t
+    // Need to store as a signed int.
+    int64_t vsyncTouchDiff = aVsyncTime - mLastTouchTime;
+    bool resample = (touchCount > 1) &&
+                    (vsyncTouchDiff > mMinResampleTime);
+
+    if (!resample) {
+      touchMove = mTouchMoveEvents.back();
+      mTouchMoveEvents.clear();
+      mTouchMoveEvents.push_back(touchMove);
+    } else {
+      ResampleTouchMoves(touchMove, aVsyncTime);
+    }
+  }
+
+  DispatchTouchEvent(touchMove);
+}
+
+static int
+Interpolate(int start, int end, int64_t aFrameDiff, int64_t aTouchDiff)
+{
+  return start + (((end - start) * aFrameDiff) / aTouchDiff);
+}
+
+static const SingleTouchData&
+GetTouchByID(const SingleTouchData& aCurrentTouch, MultiTouchInput& aOtherTouch)
+{
+  int32_t id = aCurrentTouch.mIdentifier;
+  for (size_t i = 0; i < aOtherTouch.mTouches.Length(); i++) {
+    SingleTouchData& touch = aOtherTouch.mTouches[i];
+    if (touch.mIdentifier == id) {
+      return touch;
+    }
+  }
+
+  // We can have situations where a previous touch event had 2 fingers
+  // and we lift 1 finger off. In those cases, we won't find the touch event
+  // with given id, so just return the current touch, which will be resampled
+  // without modification and dispatched.
+  return aCurrentTouch;
+}
+
+static void
+ResampleTouch(MultiTouchInput& aOutTouch, MultiTouchInput& aCurrent,
+              MultiTouchInput& aOther, int64_t aFrameDiff,
+              int64_t aTouchDiff, bool aInterpolate)
+{
+  aOutTouch = aCurrent;
+
+  // Make sure we only resample the correct finger.
+  for (size_t i = 0; i < aOutTouch.mTouches.Length(); i++) {
+    const SingleTouchData& current = aCurrent.mTouches[i];
+    const SingleTouchData& other = GetTouchByID(current, aOther);
+
+    const ScreenIntPoint& currentTouchPoint = current.mScreenPoint;
+    const ScreenIntPoint& otherTouchPoint = other.mScreenPoint;
+
+    ScreenIntPoint newSamplePoint;
+    newSamplePoint.x = Interpolate(currentTouchPoint.x, otherTouchPoint.x, aFrameDiff, aTouchDiff);
+    newSamplePoint.y = Interpolate(currentTouchPoint.y, otherTouchPoint.y, aFrameDiff, aTouchDiff);
+
+    aOutTouch.mTouches[i].mScreenPoint = newSamplePoint;
+
+#ifdef LOG_RESAMPLE_DATA
+    const char* type = "extrapolate";
+    if (aInterpolate) {
+      type = "interpolate";
+    }
+
+    float alpha = (double) aFrameDiff / (double) aTouchDiff;
+    LOG("%s current (%d, %d), other (%d, %d) to (%d, %d) alpha %f, touch diff %llu, frame diff %lld\n",
+        type,
+        currentTouchPoint.x, currentTouchPoint.y,
+        otherTouchPoint.x, otherTouchPoint.y,
+        newSamplePoint.x, newSamplePoint.y,
+        alpha, aTouchDiff, aFrameDiff);
+#endif
+  }
+}
+
+// Interpolates with the touch event prior to SampleTime
+// and with the future touch event past sample time
+int32_t
+GeckoTouchDispatcher::InterpolateTouch(MultiTouchInput& aOutTouch, uint64_t aSampleTime)
+{
+  MOZ_RELEASE_ASSERT(mTouchMoveEvents.size() >= 2);
+  mTouchQueueLock.AssertCurrentThreadOwns();
+
+  // currentTouch < SampleTime < futureTouch
+  MultiTouchInput futureTouch = mTouchMoveEvents.back();
+  mTouchMoveEvents.pop_back();
+  MultiTouchInput currentTouch = mTouchMoveEvents.back();
+
+  mTouchMoveEvents.clear();
+  mTouchMoveEvents.push_back(futureTouch);
+
+  uint64_t currentTouchTime = mLastTouchTime - mTouchTimeDiff;
+  int64_t frameDiff = aSampleTime - currentTouchTime;
+  ResampleTouch(aOutTouch, currentTouch, futureTouch, frameDiff, mTouchTimeDiff, true);
+
+  return nanosecToMillisec(frameDiff);
+}
+
+// Extrapolates from the previous two touch events before sample time
+// and extrapolates them to sample time.
+int32_t
+GeckoTouchDispatcher::ExtrapolateTouch(MultiTouchInput& aOutTouch, uint64_t aSampleTime)
+{
+  MOZ_RELEASE_ASSERT(mTouchMoveEvents.size() >= 2);
+  mTouchQueueLock.AssertCurrentThreadOwns();
+
+  // prevTouch < currentTouch < SampleTime
+  MultiTouchInput currentTouch = mTouchMoveEvents.back();
+  mTouchMoveEvents.pop_back();
+  MultiTouchInput prevTouch = mTouchMoveEvents.back();
+  mTouchMoveEvents.clear();
+  mTouchMoveEvents.push_back(currentTouch);
+
+  uint64_t currentTouchTime = mLastTouchTime;
+  int64_t maxResampleTime = std::min(mTouchTimeDiff / 2, (int64_t) mMaxPredict);
+  uint64_t maxTimestamp = currentTouchTime + maxResampleTime;
+
+  if (aSampleTime > maxTimestamp) {
+    aSampleTime = maxTimestamp;
+    #ifdef LOG_RESAMPLE_DATA
+    LOG("Overshot extrapolation time, adjusting sample time\n");
+    #endif
+  }
+
+  // This has to be signed int since it is negative
+  int64_t frameDiff = currentTouchTime - aSampleTime;
+  ResampleTouch(aOutTouch, currentTouch, prevTouch, frameDiff, mTouchTimeDiff, false);
+  return -nanosecToMillisec(frameDiff);
+}
+
+void
+GeckoTouchDispatcher::ResampleTouchMoves(MultiTouchInput& aOutTouch, uint64_t aVsyncTime)
+{
+  uint64_t sampleTime = aVsyncTime - mVsyncAdjust;
+  int32_t touchTimeAdjust = 0;
+
+  if (mLastTouchTime > sampleTime) {
+    touchTimeAdjust = InterpolateTouch(aOutTouch, sampleTime);
+  } else {
+    touchTimeAdjust = ExtrapolateTouch(aOutTouch, sampleTime);
+  }
+
+  aOutTouch.mTimeStamp += TimeDuration::FromMilliseconds(touchTimeAdjust);
+  aOutTouch.mTime += touchTimeAdjust;
+}
+
+// Some touch events get sent as mouse events. If APZ doesn't capture the event
+// and if a touch only has 1 touch input, we can send a mouse event.
+void
+GeckoTouchDispatcher::DispatchMouseEvent(MultiTouchInput& aMultiTouch,
+                                         bool aForwardToChildren)
+{
+  WidgetMouseEvent mouseEvent = ToWidgetMouseEvent(aMultiTouch, nullptr);
+  if (mouseEvent.message == NS_EVENT_NULL) {
+    return;
+  }
+
+  mouseEvent.mFlags.mNoCrossProcessBoundaryForwarding = !aForwardToChildren;
+  nsWindow::DispatchInputEvent(mouseEvent);
+}
+
+static bool
+IsExpired(const MultiTouchInput& aTouch)
+{
+  // No pending events, the filter state can be updated.
+  uint64_t timeNowMs = systemTime(SYSTEM_TIME_MONOTONIC) / 1000000;
+  return (timeNowMs - aTouch.mTime) > kInputExpirationThresholdMs;
+}
+void
+GeckoTouchDispatcher::DispatchTouchEvent(MultiTouchInput& aMultiTouch)
+{
+  if (!mTouchDownCount) {
+    mTouchEventsFiltered = IsExpired(aMultiTouch);
+  }
+
+  switch (aMultiTouch.mType) {
+    case MultiTouchInput::MULTITOUCH_START:
+      mTouchDownCount++;
+      break;
+    case MultiTouchInput::MULTITOUCH_MOVE:
+      break;
+    case MultiTouchInput::MULTITOUCH_END:
+    case MultiTouchInput::MULTITOUCH_CANCEL:
+      mTouchDownCount--;
+      if (mTouchDownCount == 0) {
+        MutexAutoLock lock(mTouchQueueLock);
+        mTouchMoveEvents.clear();
+      }
+      break;
+    default:
+      break;
+  }
+
+  if (mTouchEventsFiltered) {
+    return;
+  }
+
+  bool captured = false;
+  WidgetTouchEvent event = aMultiTouch.ToWidgetTouchEvent(nullptr);
+  nsEventStatus status = nsWindow::DispatchInputEvent(event, &captured);
+
+  if (mEnabledUniformityInfo) {
+    const char* touchAction = "Invalid";
+    switch (aMultiTouch.mType) {
+      case MultiTouchInput::MULTITOUCH_START:
+        touchAction = "Touch_Event_Down";
+        break;
+      case MultiTouchInput::MULTITOUCH_MOVE:
+        touchAction = "Touch_Event_Move";
+        break;
+      case MultiTouchInput::MULTITOUCH_END:
+      case MultiTouchInput::MULTITOUCH_CANCEL:
+        touchAction = "Touch_Event_Up";
+        break;
+    }
+
+    const SingleTouchData& firstTouch = aMultiTouch.mTouches[0];
+    const ScreenIntPoint& touchPoint = firstTouch.mScreenPoint;
+
+    LOG("UniformityInfo %s %llu %d %d", touchAction, systemTime(SYSTEM_TIME_MONOTONIC),
+        touchPoint.x, touchPoint.y);
+  }
+
+  if (!captured && (aMultiTouch.mTouches.Length() == 1)) {
+    bool forwardToChildren = status != nsEventStatus_eConsumeNoDefault;
+    DispatchMouseEvent(aMultiTouch, forwardToChildren);
+  }
+}
+
+WidgetMouseEvent
+GeckoTouchDispatcher::ToWidgetMouseEvent(const MultiTouchInput& aMultiTouch,
+                                         nsIWidget* aWidget) const
+{
+  NS_ABORT_IF_FALSE(NS_IsMainThread(),
+                    "Can only convert To WidgetMouseEvent on main thread");
+
+  uint32_t mouseEventType = NS_EVENT_NULL;
+  switch (aMultiTouch.mType) {
+    case MultiTouchInput::MULTITOUCH_START:
+      mouseEventType = NS_MOUSE_BUTTON_DOWN;
+      break;
+    case MultiTouchInput::MULTITOUCH_MOVE:
+      mouseEventType = NS_MOUSE_MOVE;
+      break;
+    case MultiTouchInput::MULTITOUCH_CANCEL:
+    case MultiTouchInput::MULTITOUCH_END:
+      mouseEventType = NS_MOUSE_BUTTON_UP;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetMouseEvent");
+      break;
+  }
+
+  WidgetMouseEvent event(true, mouseEventType, aWidget,
+                         WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
+
+  const SingleTouchData& firstTouch = aMultiTouch.mTouches[0];
+  event.refPoint.x = firstTouch.mScreenPoint.x;
+  event.refPoint.y = firstTouch.mScreenPoint.y;
+
+  event.time = aMultiTouch.mTime;
+  event.button = WidgetMouseEvent::eLeftButton;
+  event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
+  event.modifiers = aMultiTouch.modifiers;
+
+  if (mouseEventType != NS_MOUSE_MOVE) {
+    event.clickCount = 1;
+  }
+
+  return event;
+}
+
+} // namespace mozilla

widget/gonk/GeckoTouchDispatcher.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sts=2 et sw=2 tw=80: */
+/* Copyright 2014 Mozilla Foundation and Mozilla contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef GECKO_TOUCH_INPUT_DISPATCHER_h
+#define GECKO_TOUCH_INPUT_DISPATCHER_h
+
+#include "InputData.h"
+#include "Units.h"
+#include "mozilla/Mutex.h"
+#include <vector>
+
+class nsIWidget;
+
+namespace mozilla {
+class WidgetMouseEvent;
+
+// Used to resample touch events whenever a vsync event occurs. It batches
+// touch moves and on every vsync, resamples the touch position to create smooth
+// scrolls. We use the Android touch resample algorithm. It uses a combination of
+// extrapolation and interpolation. The algorithm takes the vsync time and
+// subtracts mVsyncAdjust time in ms and creates a sample time. All touch events are
+// relative to this sample time. If the last touch event occurs AFTER this
+// sample time, interpolate the last two touch events. If the last touch event occurs BEFORE
+// this sample time, we extrapolate the last two touch events to the sample
+// time. The magic numbers defined as constants are taken from android
+// InputTransport.cpp.
+class GeckoTouchDispatcher
+{
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GeckoTouchDispatcher)
+
+public:
+  GeckoTouchDispatcher();
+  void NotifyTouch(MultiTouchInput& aData, uint64_t aEventTime);
+  void DispatchTouchEvent(MultiTouchInput& aMultiTouch);
+  void DispatchTouchMoveEvents(uint64_t aVsyncTime);
+  static bool NotifyVsync(uint64_t aVsyncTimestamp);
+
+private:
+  int32_t InterpolateTouch(MultiTouchInput& aOutTouch, uint64_t aSampleTime);
+  int32_t ExtrapolateTouch(MultiTouchInput& aOutTouch, uint64_t aSampleTime);
+  void ResampleTouchMoves(MultiTouchInput& aOutTouch, uint64_t vsyncTime);
+  void SendTouchEvent(MultiTouchInput& aData);
+  void DispatchMouseEvent(MultiTouchInput& aMultiTouch,
+                          bool aForwardToChildren);
+  WidgetMouseEvent ToWidgetMouseEvent(const MultiTouchInput& aData, nsIWidget* aWidget) const;
+
+  // mTouchQueueLock are used to protect the vector below
+  // as it is accessed on the vsync thread and main thread
+  Mutex mTouchQueueLock;
+  std::vector<MultiTouchInput> mTouchMoveEvents;
+
+  bool mResamplingEnabled;
+  bool mTouchEventsFiltered;
+  bool mEnabledUniformityInfo;
+  int mTouchDownCount;
+
+  // All times below are in nanoseconds
+  int32_t mVsyncAdjust;     // Time from vsync we create sample times from
+  int32_t mMaxPredict;      // How far into the future we're allowed to extrapolate
+
+  // Amount of time between vsync and the last event that is required before we
+  // resample
+  int32_t mMinResampleTime;
+
+  // The time difference between the last two touch move events
+  int64_t mTouchTimeDiff;
+
+  // The system time at which the last touch event occured
+  uint64_t mLastTouchTime;
+};
+
+} // namespace mozilla
+#endif // GECKO_TOUCH_INPUT_DISPATCHER_h

widget/gonk/HwcComposer2D.cpp

@@ -28,6 +28,7 @@
 #include "mozilla/StaticPtr.h"
 #include "cutils/properties.h"
 #include "gfx2DGlue.h"
+#include "GeckoTouchDispatcher.h"
 
 #if ANDROID_VERSION >= 17
 #include "libdisplay/FramebufferSurface.h"
@@ -149,6 +150,10 @@ HwcComposer2D::Init(hwc_display_t dpy, hwc_surface_t sur, gl::GLContext* aGLCont
         mColorFill = false;
         mRBSwapSupport = false;
     }
+
+    if (RegisterHwcEventCallback()) {
+        EnableVsync(true);
+    }
 #else
     char propValue[PROPERTY_VALUE_MAX];
     property_get("ro.display.colorfill", propValue, "0");
@@ -223,7 +228,7 @@ HwcComposer2D::RunVsyncEventControl(bool aEnable)
 void
 HwcComposer2D::Vsync(int aDisplay, int64_t aTimestamp)
 {
-    // TODO: Handle Vsync event here
+    GeckoTouchDispatcher::NotifyVsync(aTimestamp);
 }
 #endif
 

widget/gonk/moz.build

@@ -44,6 +44,7 @@ SOURCES += ['libui/' + src for src in [
 ]]
 
 SOURCES += [
+    'GeckoTouchDispatcher.cpp',
     'GfxInfo.cpp',
     'GonkMemoryPressureMonitoring.cpp',
     'GonkPermission.cpp',

widget/gonk/nsAppShell.cpp

@@ -72,6 +72,7 @@
 
 // Defines kKeyMapping and GetKeyNameIndex()
 #include "GonkKeyMapping.h"
+#include "GeckoTouchDispatcher.h"
 
 #define LOG(args...)                                            \
     __android_log_print(ANDROID_LOG_INFO, "Gonk" , ## args)
@@ -157,14 +158,12 @@ struct UserInputData {
             ::Touch touches[MAX_POINTERS];
         } motion;
     };
-
-    Modifiers DOMModifiers() const;
 };
 
-Modifiers
+static mozilla::Modifiers
-UserInputData::DOMModifiers() const
+getDOMModifiers(int32_t metaState)
 {
-    Modifiers result = 0;
+    mozilla::Modifiers result = 0;
     if (metaState & (AMETA_ALT_ON | AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
         result |= MODIFIER_ALT;
     }
@@ -195,106 +194,6 @@ UserInputData::DOMModifiers() const
     return result;
 }
 
-static void
-sendMouseEvent(uint32_t msg, UserInputData& data, bool forwardToChildren)
-{
-    WidgetMouseEvent event(true, msg, nullptr,
-                           WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
-
-    event.refPoint.x = data.motion.touches[0].coords.getX();
-    event.refPoint.y = data.motion.touches[0].coords.getY();
-    event.time = data.timeMs;
-    event.button = WidgetMouseEvent::eLeftButton;
-    event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
-    if (msg != NS_MOUSE_MOVE)
-        event.clickCount = 1;
-    event.modifiers = data.DOMModifiers();
-
-    event.mFlags.mNoCrossProcessBoundaryForwarding = !forwardToChildren;
-
-    nsWindow::DispatchInputEvent(event);
-}
-
-static void
-addDOMTouch(UserInputData& data, WidgetTouchEvent& event, int i)
-{
-    const ::Touch& touch = data.motion.touches[i];
-    event.touches.AppendElement(
-        new dom::Touch(touch.id,
-                       nsIntPoint(floor(touch.coords.getX() + 0.5), floor(touch.coords.getY() + 0.5)),
-                       nsIntPoint(touch.coords.getAxisValue(AMOTION_EVENT_AXIS_SIZE),
-                                  touch.coords.getAxisValue(AMOTION_EVENT_AXIS_SIZE)),
-                       0,
-                       touch.coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE))
-    );
-}
-
-static void
-printUniformityInfo(UserInputData& aData)
-{
-    char* touchAction;
-    const ::Touch& touch = aData.motion.touches[0];
-    int32_t action = aData.action & AMOTION_EVENT_ACTION_MASK;
-    switch (action) {
-    case AMOTION_EVENT_ACTION_DOWN:
-         touchAction = "Touch_Event_Down";
-         break;
-    case AMOTION_EVENT_ACTION_MOVE:
-         touchAction = "Touch_Event_Move";
-          break;
-    case AMOTION_EVENT_ACTION_UP:
-         touchAction = "Touch_Event_Up";
-         break;
-    default :
-         return;
-    }
-    LOG("UniformityInfo %s %llu %f %f", touchAction, systemTime(SYSTEM_TIME_MONOTONIC),
-        touch.coords.getX(),  touch.coords.getY() );
-}
-
-static nsEventStatus
-sendTouchEvent(UserInputData& data, bool* captured)
-{
-    uint32_t msg;
-    int32_t action = data.action & AMOTION_EVENT_ACTION_MASK;
-    switch (action) {
-    case AMOTION_EVENT_ACTION_DOWN:
-    case AMOTION_EVENT_ACTION_POINTER_DOWN:
-        msg = NS_TOUCH_START;
-        break;
-    case AMOTION_EVENT_ACTION_MOVE:
-        msg = NS_TOUCH_MOVE;
-        break;
-    case AMOTION_EVENT_ACTION_UP:
-    case AMOTION_EVENT_ACTION_POINTER_UP:
-        msg = NS_TOUCH_END;
-        break;
-    case AMOTION_EVENT_ACTION_OUTSIDE:
-    case AMOTION_EVENT_ACTION_CANCEL:
-        msg = NS_TOUCH_CANCEL;
-        break;
-    default:
-        return nsEventStatus_eIgnore;
-    }
-
-    WidgetTouchEvent event(true, msg, nullptr);
-
-    event.time = data.timeMs;
-    event.modifiers = data.DOMModifiers();
-
-    int32_t i;
-    if (msg == NS_TOUCH_END) {
-        i = data.action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK;
-        i >>= AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
-        addDOMTouch(data, event, i);
-    } else {
-        for (i = 0; i < data.motion.touchCount; ++i)
-            addDOMTouch(data, event, i);
-    }
-
-    return nsWindow::DispatchInputEvent(event, captured);
-}
-
 class MOZ_STACK_CLASS KeyEventDispatcher
 {
 public:
@@ -405,7 +304,7 @@ KeyEventDispatcher::DispatchKeyEventInternal(uint32_t aEventMessage)
         event.mKeyValue = mDOMPrintableKeyValue;
     }
     event.mCodeNameIndex = mDOMCodeNameIndex;
-    event.modifiers = mData.DOMModifiers();
+    event.modifiers = getDOMModifiers(mData.metaState);
     event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_MOBILE;
     event.time = mData.timeMs;
     return nsWindow::DispatchInputEvent(event);
@@ -594,12 +493,10 @@ public:
     GeckoInputDispatcher(sp<EventHub> &aEventHub)
         : mQueueLock("GeckoInputDispatcher::mQueueMutex")
         , mEventHub(aEventHub)
-        , mTouchDownCount(0)
         , mKeyDownCount(0)
-        , mTouchEventsFiltered(false)
         , mKeyEventsFiltered(false)
     {
-      mEnabledUniformityInfo = Preferences::GetBool("layers.uniformity-info", false);
+        mTouchDispatcher = new GeckoTouchDispatcher();
     }
 
     virtual void dump(String8& dump);
@@ -644,13 +541,10 @@ private:
     mozilla::Mutex mQueueLock;
     std::queue<UserInputData> mEventQueue;
     sp<EventHub> mEventHub;
+    nsRefPtr<GeckoTouchDispatcher> mTouchDispatcher;
 
-    int mTouchDownCount;
     int mKeyDownCount;
-    bool mTouchEventsFiltered;
     bool mKeyEventsFiltered;
-    BitSet32 mTouchDown;
-    bool mEnabledUniformityInfo;
 };
 
 // GeckoInputReaderPolicy
@@ -722,80 +616,7 @@ GeckoInputDispatcher::dispatchOnce()
 
     switch (data.type) {
     case UserInputData::MOTION_DATA: {
-        if (!mTouchDownCount) {
+        MOZ_ASSERT_UNREACHABLE("Should not dispatch touch events here anymore");
-            // No pending events, the filter state can be updated.
-            mTouchEventsFiltered = isExpired(data);
-        }
-
-        int32_t action = data.action & AMOTION_EVENT_ACTION_MASK;
-        int32_t index = data.action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK;
-        index >>= AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
-        int32_t id = data.motion.touches[index].id;
-        switch (action) {
-        case AMOTION_EVENT_ACTION_DOWN:
-        case AMOTION_EVENT_ACTION_POINTER_DOWN:
-            if (!mTouchDown.hasBit(id)) {
-                mTouchDown.markBit(id);
-                mTouchDownCount++;
-            }
-            break;
-        case AMOTION_EVENT_ACTION_MOVE:
-        case AMOTION_EVENT_ACTION_HOVER_MOVE:
-            // No need to update the count on move.
-            break;
-        case AMOTION_EVENT_ACTION_UP:
-        case AMOTION_EVENT_ACTION_POINTER_UP:
-        case AMOTION_EVENT_ACTION_OUTSIDE:
-        case AMOTION_EVENT_ACTION_CANCEL:
-            if (mTouchDown.hasBit(id)) {
-                mTouchDown.clearBit(id);
-                mTouchDownCount--;
-            }
-            break;
-        default:
-            break;
-        }
-
-        if (mTouchEventsFiltered) {
-            return;
-        }
-
-        nsEventStatus status = nsEventStatus_eIgnore;
-        if (action != AMOTION_EVENT_ACTION_HOVER_MOVE) {
-            bool captured;
-            status = sendTouchEvent(data, &captured);
-            if (mEnabledUniformityInfo) {
-                printUniformityInfo(data);
-            }
-            if (captured) {
-                return;
-            }
-        }
-
-        uint32_t msg;
-        switch (action) {
-        case AMOTION_EVENT_ACTION_DOWN:
-            msg = NS_MOUSE_BUTTON_DOWN;
-            break;
-        case AMOTION_EVENT_ACTION_POINTER_DOWN:
-        case AMOTION_EVENT_ACTION_POINTER_UP:
-        case AMOTION_EVENT_ACTION_MOVE:
-        case AMOTION_EVENT_ACTION_HOVER_MOVE:
-            msg = NS_MOUSE_MOVE;
-            break;
-        case AMOTION_EVENT_ACTION_OUTSIDE:
-        case AMOTION_EVENT_ACTION_CANCEL:
-        case AMOTION_EVENT_ACTION_UP:
-            msg = NS_MOUSE_BUTTON_UP;
-            break;
-        default:
-            msg = NS_EVENT_NULL;
-            break;
-        }
-        if (msg != NS_EVENT_NULL) {
-            sendMouseEvent(msg, data, 
-                           status != nsEventStatus_eConsumeNoDefault);
-        }
         break;
     }
     case UserInputData::KEY_DATA: {
@@ -841,41 +662,72 @@ GeckoInputDispatcher::notifyKey(const NotifyKeyArgs* args)
     gAppShell->NotifyNativeEvent();
 }
 
+static void
+addMultiTouch(MultiTouchInput& aMultiTouch,
+                                    const NotifyMotionArgs* args, int aIndex)
+{
+    int32_t id = args->pointerProperties[aIndex].id;
+    PointerCoords coords = args->pointerCoords[aIndex];
+    float force = coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE);
+    ScreenIntPoint point(floor(coords.getX() + 0.5),
+                         floor(coords.getY() + 0.5));
+
+    SingleTouchData touchData(id, point, ScreenSize(0, 0),
+                              0, force);
+
+    aMultiTouch.mTouches.AppendElement(touchData);
+}
 
 void
 GeckoInputDispatcher::notifyMotion(const NotifyMotionArgs* args)
 {
-    UserInputData data;
+    uint32_t time = nanosecsToMillisecs(args->eventTime);
-    data.timeMs = nanosecsToMillisecs(args->eventTime);
+    int32_t action = args->action & AMOTION_EVENT_ACTION_MASK;
-    data.type = UserInputData::MOTION_DATA;
+    int touchCount = args->pointerCount;
-    data.action = args->action;
+    MOZ_ASSERT(touchCount <= MAX_POINTERS);
-    data.flags = args->flags;
+    TimeStamp timestamp = TimeStamp::Now();
-    data.metaState = args->metaState;
+    Modifiers modifiers = getDOMModifiers(args->metaState);
-    data.deviceId = args->deviceId;
+
-    MOZ_ASSERT(args->pointerCount <= MAX_POINTERS);
+    MultiTouchInput::MultiTouchType touchType = MultiTouchInput::MULTITOUCH_CANCEL;
-    data.motion.touchCount = args->pointerCount;
+    switch (action) {
-    for (uint32_t i = 0; i < args->pointerCount; ++i) {
+    case AMOTION_EVENT_ACTION_DOWN:
-        ::Touch& touch = data.motion.touches[i];
+    case AMOTION_EVENT_ACTION_POINTER_DOWN:
-        touch.id = args->pointerProperties[i].id;
+        touchType = MultiTouchInput::MULTITOUCH_START;
-        memcpy(&touch.coords, &args->pointerCoords[i], sizeof(*args->pointerCoords));
+        break;
+    case AMOTION_EVENT_ACTION_MOVE:
+        touchType = MultiTouchInput::MULTITOUCH_MOVE;
+        break;
+    case AMOTION_EVENT_ACTION_UP:
+    case AMOTION_EVENT_ACTION_POINTER_UP:
+        touchType = MultiTouchInput::MULTITOUCH_END;
+        break;
+    case AMOTION_EVENT_ACTION_OUTSIDE:
+    case AMOTION_EVENT_ACTION_CANCEL:
+        touchType = MultiTouchInput::MULTITOUCH_CANCEL;
+        break;
+    default:
+        MOZ_ASSERT_UNREACHABLE("Could not assign a touch type");
+        break;
     }
-    {
+
-        MutexAutoLock lock(mQueueLock);
+    MultiTouchInput touchData(touchType, time, timestamp, modifiers);
-        if (!mEventQueue.empty() &&
+
-             mEventQueue.back().type == UserInputData::MOTION_DATA &&
+    // For touch ends, we have to filter out which finger is actually
-           ((mEventQueue.back().action & AMOTION_EVENT_ACTION_MASK) ==
+    // the touch end since the touch array has all fingers, not just the touch
-             AMOTION_EVENT_ACTION_MOVE ||
+    // that we want to end
-            (mEventQueue.back().action & AMOTION_EVENT_ACTION_MASK) ==
+    if (touchType == MultiTouchInput::MULTITOUCH_END) {
-             AMOTION_EVENT_ACTION_HOVER_MOVE))
+        int touchIndex = args->action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK;
-            mEventQueue.back() = data;
+        touchIndex >>= AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
-        else
+        addMultiTouch(touchData, args, touchIndex);
-            mEventQueue.push(data);
+    } else {
+        for (int32_t i = 0; i < touchCount; ++i) {
+            addMultiTouch(touchData, args, i);
+        }
     }
-    gAppShell->NotifyNativeEvent();
+
+    mTouchDispatcher->NotifyTouch(touchData, args->eventTime);
 }
 
-
-
 void GeckoInputDispatcher::notifySwitch(const NotifySwitchArgs* args)
 {
     if (!sDevInputAudioJack)