The Tor Browser: widget/windows/winrt/MetroInput.cpp@ac0c01689b40 (annotated)

widget/windows/winrt/MetroInput.cpp@ac0c01689b40 (annotated)

widget/windows/winrt/MetroInput.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 // Moz headers (alphabetical)
 #include "MetroInput.h"
 #include "MetroUtils.h" // Logging, POINT_CEIL_*, ActivateGenericInstance, etc
 #include "MetroWidget.h" // MetroInput::mWidget
 #include "mozilla/dom/Touch.h"  // Touch
 #include "nsTArray.h" // Touch lists
 #include "nsIDOMSimpleGestureEvent.h" // Constants for gesture events
 #include "InputData.h"
 #include "UIABridgePrivate.h"
 #include "MetroAppShell.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/TouchEvents.h"
 #include "mozilla/Preferences.h"  // for Preferences
 #include "WinUtils.h"
 #include "nsIPresShell.h"
 // System headers (alphabetical)
 #include <windows.ui.core.h> // ABI::Window::UI::Core namespace
 #include <windows.ui.input.h> // ABI::Window::UI::Input namespace
 //#define DEBUG_INPUT
 // Using declarations
 using namespace ABI::Windows; // UI, System, Foundation namespaces
 using namespace Microsoft; // WRL namespace (ComPtr, possibly others)
 using namespace mozilla;
 using namespace mozilla::widget;
 using namespace mozilla::widget::winrt;
 using namespace mozilla::dom;
 // File-scoped statics (unnamed namespace)
 namespace {
   // XXX: Set these min values appropriately
   const double SWIPE_MIN_DISTANCE = 5.0;
   const double SWIPE_MIN_VELOCITY = 5.0;
   // Convenience typedefs for event handler types
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CEdgeGesture_Windows__CUI__CInput__CEdgeGestureEventArgs_t EdgeGestureHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CCore__CCoreDispatcher_Windows__CUI__CCore__CAcceleratorKeyEventArgs_t AcceleratorKeyActivatedHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CPointerEventArgs_t PointerEventHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CGestureRecognizer_Windows__CUI__CInput__CTappedEventArgs_t TappedEventHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CGestureRecognizer_Windows__CUI__CInput__CRightTappedEventArgs_t RightTappedEventHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CGestureRecognizer_Windows__CUI__CInput__CManipulationStartedEventArgs_t ManipulationStartedEventHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CGestureRecognizer_Windows__CUI__CInput__CManipulationUpdatedEventArgs_t ManipulationUpdatedEventHandler;
   typedef Foundation::__FITypedEventHandler_2_Windows__CUI__CInput__CGestureRecognizer_Windows__CUI__CInput__CManipulationCompletedEventArgs_t ManipulationCompletedEventHandler;
   // Other convenience typedefs
   typedef ABI::Windows::UI::Core::ICoreAcceleratorKeys ICoreAcceleratorKeys;
   /**
    * Specifies whether touch-action property is in force.
    */
   static bool gTouchActionPropertyEnabled = false;
   /**
    * Creates and returns a new {@link Touch} from the given
    * ABI::Windows::UI::Input::IPointerPoint.  Note that the caller is
    * responsible for freeing the memory for the Touch returned from
    * this function.
    *
    * @param aPoint the ABI::Windows::UI::Input::IPointerPoint containing the
    *               metadata from which to create our new {@link Touch}
    * @return a new {@link Touch} representing the touch point. The caller
    *         is responsible for freeing the memory for this touch point.
    */
   Touch*
   CreateDOMTouch(UI::Input::IPointerPoint* aPoint) {
     WRL::ComPtr<UI::Input::IPointerPointProperties> props;
     Foundation::Point position;
     uint32_t pointerId;
     Foundation::Rect contactRect;
     float pressure;
     float tiltX;
     float tiltY;
     aPoint->get_Properties(props.GetAddressOf());
     aPoint->get_Position(&position);
     aPoint->get_PointerId(&pointerId);
     props->get_ContactRect(&contactRect);
     props->get_Pressure(&pressure);
     props->get_XTilt(&tiltX);
     props->get_YTilt(&tiltY);
     nsIntPoint touchPoint = MetroUtils::LogToPhys(position);
     nsIntPoint touchRadius;
     touchRadius.x = WinUtils::LogToPhys(contactRect.Width) / 2;
     touchRadius.y = WinUtils::LogToPhys(contactRect.Height) / 2;
     Touch* touch =
            new Touch(pointerId,
                      touchPoint,
                      // Rotation radius and angle.
                      // W3C touch events v1 do not use these.
                      // The draft for W3C touch events v2 explains that
                      // radius and angle should describe the ellipse that
                      // most closely circumscribes the touching area.  Since
                      // Windows gives us a bounding rectangle rather than an
                      // ellipse, we provide the ellipse that is most closely
                      // circumscribed by the bounding rectangle that Windows
                      // gave us.
                      touchRadius,
 .0f,
                      // Pressure
                      // W3C touch events v1 do not use this.
                      // The current draft for W3C touch events v2 says that
                      // this should be a value between 0.0 and 1.0, which is
                      // consistent with what Windows provides us here.
                      // XXX: Windows defaults to 0.5, but the current W3C
                      // draft says that the value should be 0.0 if no value
                      // known.
                      pressure);
     touch->tiltX = tiltX;
     touch->tiltY = tiltY;
     return touch;
   }
   /**
    * Test if a touchpoint position has moved. See Touch.Equals for
    * criteria.
    *
    * @param aTouch previous touch point
    * @param aPoint new winrt touch point
    * @return true if the point has moved
    */
   bool
   HasPointMoved(Touch* aTouch, UI::Input::IPointerPoint* aPoint) {
     WRL::ComPtr<UI::Input::IPointerPointProperties> props;
     Foundation::Point position;
     Foundation::Rect contactRect;
     float pressure;
     aPoint->get_Properties(props.GetAddressOf());
     aPoint->get_Position(&position);
     props->get_ContactRect(&contactRect);
     props->get_Pressure(&pressure);
     nsIntPoint touchPoint = MetroUtils::LogToPhys(position);
     nsIntPoint touchRadius;
     touchRadius.x = WinUtils::LogToPhys(contactRect.Width) / 2;
     touchRadius.y = WinUtils::LogToPhys(contactRect.Height) / 2;
     // from Touch.Equals
     return touchPoint != aTouch->mRefPoint ||
            pressure != aTouch->Force() ||
            /* mRotationAngle == aTouch->RotationAngle() || */
            touchRadius.x != aTouch->RadiusX() ||
            touchRadius.y != aTouch->RadiusY();
   }
   /**
    * Converts from the Devices::Input::PointerDeviceType enumeration
    * to a nsIDOMMouseEvent::MOZ_SOURCE_* value.
    *
    * @param aDeviceType the value to convert
    * @param aMozInputSource the converted value
    */
   void
   MozInputSourceFromDeviceType(
               Devices::Input::PointerDeviceType const& aDeviceType,
               unsigned short& aMozInputSource) {
     if (Devices::Input::PointerDeviceType::PointerDeviceType_Mouse
                   == aDeviceType) {
       aMozInputSource = nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
     } else if (Devices::Input::PointerDeviceType::PointerDeviceType_Touch
                   == aDeviceType) {
       aMozInputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
     } else if (Devices::Input::PointerDeviceType::PointerDeviceType_Pen
                   == aDeviceType) {
       aMozInputSource = nsIDOMMouseEvent::MOZ_SOURCE_PEN;
     }
   }
   int16_t
   ButtonsForPointerPoint(UI::Input::IPointerPoint* aPoint) {
     WRL::ComPtr<UI::Input::IPointerPointProperties> props;
     aPoint->get_Properties(props.GetAddressOf());
     int16_t buttons = 0;
     boolean buttonPressed;
     props->get_IsLeftButtonPressed(&buttonPressed);
     if (buttonPressed) {
       buttons |= WidgetMouseEvent::eLeftButtonFlag;
     }
     props->get_IsMiddleButtonPressed(&buttonPressed);
     if (buttonPressed) {
       buttons |= WidgetMouseEvent::eMiddleButtonFlag;
     }
     props->get_IsRightButtonPressed(&buttonPressed);
     if (buttonPressed) {
       buttons |= WidgetMouseEvent::eRightButtonFlag;
     }
     props->get_IsXButton1Pressed(&buttonPressed);
     if (buttonPressed) {
       buttons |= WidgetMouseEvent::e4thButtonFlag;
     }
     props->get_IsXButton2Pressed(&buttonPressed);
     if (buttonPressed) {
       buttons |= WidgetMouseEvent::e5thButtonFlag;
     }
     return buttons;
   }
   /**
    * This function is for use with mTouches.Enumerate.  It will
    * append each element it encounters to the {@link nsTArray}
    * of {@link mozilla::dom::Touch}es passed in through the third (void*)
    * parameter.
    *
    * NOTE: This function will set the `mChanged` member of each
    * element it encounters to `false`, since this function is only
    * used to populate a touchlist that is about to be dispatched
    * in a gecko touch event.
    *
    * @param aKey the key of the current element being enumerated
    * @param aData the value of the current element being enumerated
    * @param aTouchList the {@link nsTArray} to append to
    */
   PLDHashOperator
   AppendToTouchList(const unsigned int& aKey,
                     nsRefPtr<Touch>& aData,
                     void *aTouchList)
   {
     nsTArray<nsRefPtr<Touch> > *touches =
               static_cast<nsTArray<nsRefPtr<Touch> > *>(aTouchList);
     nsRefPtr<Touch> copy = new Touch(aData->mIdentifier,
                aData->mRefPoint,
                aData->mRadius,
                aData->mRotationAngle,
                aData->mForce);
     copy->tiltX = aData->tiltX;
     copy->tiltY = aData->tiltY;
     touches->AppendElement(copy);
     aData->mChanged = false;
     return PL_DHASH_NEXT;
   }
   // Helper for making sure event ptrs get freed.
   class AutoDeleteEvent
   {
   public:
     AutoDeleteEvent(WidgetGUIEvent* aPtr) :
       mPtr(aPtr) {}
     ~AutoDeleteEvent() {
       if (mPtr) {
         delete mPtr;
       }
     }
     WidgetGUIEvent* mPtr;
   };
 }
 namespace mozilla {
 namespace widget {
 namespace winrt {
 MetroInput::InputPrecisionLevel MetroInput::sCurrentInputLevel =
   MetroInput::InputPrecisionLevel::LEVEL_IMPRECISE;
 MetroInput::MetroInput(MetroWidget* aWidget,
                        UI::Core::ICoreWindow* aWindow)
               : mWidget(aWidget),
                 mNonApzTargetForTouch(false),
                 mWindow(aWindow)
 {
   LogFunction();
   NS_ASSERTION(aWidget, "Attempted to create MetroInput for null widget!");
   NS_ASSERTION(aWindow, "Attempted to create MetroInput for null window!");
   Preferences::AddBoolVarCache(&gTouchActionPropertyEnabled, "layout.css.touch_action.enabled", gTouchActionPropertyEnabled);
   mTokenPointerPressed.value = 0;
   mTokenPointerReleased.value = 0;
   mTokenPointerMoved.value = 0;
   mTokenPointerEntered.value = 0;
   mTokenPointerExited.value = 0;
   mTokenEdgeStarted.value = 0;
   mTokenEdgeCanceled.value = 0;
   mTokenEdgeCompleted.value = 0;
   mTokenManipulationCompleted.value = 0;
   mTokenTapped.value = 0;
   mTokenRightTapped.value = 0;
   // Create our Gesture Recognizer
   ActivateGenericInstance(RuntimeClass_Windows_UI_Input_GestureRecognizer,
                           mGestureRecognizer);
   NS_ASSERTION(mGestureRecognizer, "Failed to create GestureRecognizer!");
   RegisterInputEvents();
 }
 MetroInput::~MetroInput()
 {
   LogFunction();
   UnregisterInputEvents();
 }
 /* static */
 bool MetroInput::IsInputModeImprecise()
 {
   return sCurrentInputLevel == LEVEL_IMPRECISE;
 }
 /**
  * Tracks the current input level (precise/imprecise) and fires an observer
  * when the mode changes.
  */
 void
 MetroInput::UpdateInputLevel(InputPrecisionLevel aInputLevel)
 {
   // ignore mouse input if we have active touch input.
   if (aInputLevel == LEVEL_PRECISE && mTouches.Count() > 0) {
     return;
   }
   if (sCurrentInputLevel != aInputLevel) {
     sCurrentInputLevel = aInputLevel;
     MetroUtils::FireObserver(sCurrentInputLevel == LEVEL_PRECISE ?
                                "metro_precise_input" : "metro_imprecise_input");
   }
 }
 /**
  * Processes an IEdgeGestureEventArgs and returns the input source type
  * for the event. Also updates input level via UpdateInputLevel.
  */
 uint16_t
 MetroInput::ProcessInputTypeForGesture(UI::Input::IEdgeGestureEventArgs* aArgs)
 {
   MOZ_ASSERT(aArgs);
   UI::Input::EdgeGestureKind kind;
   aArgs->get_Kind(&kind);
   switch(kind) {
     case UI::Input::EdgeGestureKind::EdgeGestureKind_Touch:
       UpdateInputLevel(LEVEL_IMPRECISE);
       return nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
     break;
     case UI::Input::EdgeGestureKind::EdgeGestureKind_Keyboard:
       return nsIDOMMouseEvent::MOZ_SOURCE_KEYBOARD;
     break;
     case UI::Input::EdgeGestureKind::EdgeGestureKind_Mouse:
       UpdateInputLevel(LEVEL_PRECISE);
       return nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
     break;
   }
   return nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
 }
 /**
  * When the user swipes her/his finger in from the top of the screen,
  * we receive this event.
  *
  * @param sender the CoreDispatcher that fired this event
  * @param aArgs the event-specific args we use when processing this event
  * @returns S_OK
  */
 HRESULT
 MetroInput::OnEdgeGestureStarted(UI::Input::IEdgeGesture* sender,
                                  UI::Input::IEdgeGestureEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WidgetSimpleGestureEvent geckoEvent(true,
                                       NS_SIMPLE_GESTURE_EDGE_STARTED,
                                       mWidget.Get());
   mModifierKeyState.Update();
   mModifierKeyState.InitInputEvent(geckoEvent);
   geckoEvent.time = ::GetMessageTime();
   geckoEvent.inputSource = ProcessInputTypeForGesture(aArgs);
   // Safe
   DispatchEventIgnoreStatus(&geckoEvent);
   return S_OK;
 }
 /**
  * This event can be received if the user swipes her/his finger back to
  * the top of the screen, or continues moving her/his finger such that
  * the movement is interpreted as a "grab this window" gesture
  *
  * @param sender the CoreDispatcher that fired this event
  * @param aArgs the event-specific args we use when processing this event
  * @returns S_OK
  */
 HRESULT
 MetroInput::OnEdgeGestureCanceled(UI::Input::IEdgeGesture* sender,
                                   UI::Input::IEdgeGestureEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WidgetSimpleGestureEvent geckoEvent(true,
                                       NS_SIMPLE_GESTURE_EDGE_CANCELED,
                                       mWidget.Get());
   mModifierKeyState.Update();
   mModifierKeyState.InitInputEvent(geckoEvent);
   geckoEvent.time = ::GetMessageTime();
   geckoEvent.inputSource = ProcessInputTypeForGesture(aArgs);
   // Safe
   DispatchEventIgnoreStatus(&geckoEvent);
   return S_OK;
 }
 /**
  * This event is received if the user presses ctrl+Z or lifts her/his
  * finger after causing an EdgeGestureStarting event to fire.
  *
  * @param sender the CoreDispatcher that fired this event
  * @param aArgs the event-specific args we use when processing this event
  * @returns S_OK
  */
 HRESULT
 MetroInput::OnEdgeGestureCompleted(UI::Input::IEdgeGesture* sender,
                                    UI::Input::IEdgeGestureEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WidgetSimpleGestureEvent geckoEvent(true,
                                       NS_SIMPLE_GESTURE_EDGE_COMPLETED,
                                       mWidget.Get());
   mModifierKeyState.Update();
   mModifierKeyState.InitInputEvent(geckoEvent);
   geckoEvent.time = ::GetMessageTime();
   geckoEvent.inputSource = ProcessInputTypeForGesture(aArgs);
   // Safe
   DispatchEventIgnoreStatus(&geckoEvent);
   return S_OK;
 }
 /**
  * This helper function is used by our processing of PointerPressed,
  * PointerReleased, and PointerMoved events.
  * It dispatches a gecko event in response to the input received.  This
  * function should only be called for non-touch (i.e. pen or mouse) input
  * events.
  *
  * @param aPoint the PointerPoint for the input event
  */
 void
 MetroInput::OnPointerNonTouch(UI::Input::IPointerPoint* aPoint) {
   WRL::ComPtr<UI::Input::IPointerPointProperties> props;
   UI::Input::PointerUpdateKind pointerUpdateKind;
   aPoint->get_Properties(props.GetAddressOf());
   props->get_PointerUpdateKind(&pointerUpdateKind);
   uint32_t message = NS_MOUSE_MOVE;
   int16_t button = 0;
   switch (pointerUpdateKind) {
     case UI::Input::PointerUpdateKind::PointerUpdateKind_LeftButtonPressed:
       button = WidgetMouseEvent::buttonType::eLeftButton;
       message = NS_MOUSE_BUTTON_DOWN;
       break;
     case UI::Input::PointerUpdateKind::PointerUpdateKind_MiddleButtonPressed:
       button = WidgetMouseEvent::buttonType::eMiddleButton;
       message = NS_MOUSE_BUTTON_DOWN;
       break;
     case UI::Input::PointerUpdateKind::PointerUpdateKind_RightButtonPressed:
       button = WidgetMouseEvent::buttonType::eRightButton;
       message = NS_MOUSE_BUTTON_DOWN;
       break;
     case UI::Input::PointerUpdateKind::PointerUpdateKind_LeftButtonReleased:
       button = WidgetMouseEvent::buttonType::eLeftButton;
       message = NS_MOUSE_BUTTON_UP;
       break;
     case UI::Input::PointerUpdateKind::PointerUpdateKind_MiddleButtonReleased:
       button = WidgetMouseEvent::buttonType::eMiddleButton;
       message = NS_MOUSE_BUTTON_UP;
       break;
     case UI::Input::PointerUpdateKind::PointerUpdateKind_RightButtonReleased:
       button = WidgetMouseEvent::buttonType::eRightButton;
       message = NS_MOUSE_BUTTON_UP;
       break;
   }
   UpdateInputLevel(LEVEL_PRECISE);
   WidgetMouseEvent* event =
     new WidgetMouseEvent(true, message, mWidget.Get(),
                          WidgetMouseEvent::eReal,
                          WidgetMouseEvent::eNormal);
   event->button = button;
   aPoint->get_PointerId(&event->pointerId);
   InitGeckoMouseEventFromPointerPoint(event, aPoint);
   DispatchAsyncEventIgnoreStatus(event);
 }
 void
 MetroInput::InitTouchEventTouchList(WidgetTouchEvent* aEvent)
 {
   MOZ_ASSERT(aEvent);
   mTouches.Enumerate(&AppendToTouchList,
                       static_cast<void*>(&aEvent->touches));
 }
 bool
 MetroInput::ShouldDeliverInputToRecognizer()
 {
   return mRecognizerWantsEvents;
 }
 void
 MetroInput::GetAllowedTouchBehavior(WidgetTouchEvent* aTransformedEvent, nsTArray<TouchBehaviorFlags>& aOutBehaviors)
 {
   mWidget->ApzcGetAllowedTouchBehavior(aTransformedEvent, aOutBehaviors);
   for (uint32_t i = 0; i < aOutBehaviors.Length(); i++) {
     if (aOutBehaviors[i] & AllowedTouchBehavior::UNKNOWN) {
       // performing hit testing fallback: asking content to perform hit testing itself
       // (in spite that this operation has high latency).
       aOutBehaviors[i] = mWidget->ContentGetAllowedTouchBehavior(aTransformedEvent->touches[i]->mRefPoint);
     }
   }
 }
 bool
 MetroInput::IsTouchBehaviorForbidden(const nsTArray<TouchBehaviorFlags>& aTouchBehaviors)
 {
   for (size_t i = 0; i < aTouchBehaviors.Length(); i++) {
     if (aTouchBehaviors[i] == AllowedTouchBehavior::NONE)
       return true;
   }
   return false;
 }
 // This event is raised when the user pushes the left mouse button, presses a
 // pen to the surface, or presses a touch screen.
 HRESULT
 MetroInput::OnPointerPressed(UI::Core::ICoreWindow* aSender,
                              UI::Core::IPointerEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WRL::ComPtr<UI::Input::IPointerPoint> currentPoint;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_CurrentPoint(currentPoint.GetAddressOf());
   currentPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   // For mouse and pen input, simply call our helper function
   if (deviceType !=
           Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     OnPointerNonTouch(currentPoint.Get());
     mGestureRecognizer->ProcessDownEvent(currentPoint.Get());
     return S_OK;
   }
   // This is touch input.
   UpdateInputLevel(LEVEL_IMPRECISE);
   // Create the new touch point and add it to our event.
   uint32_t pointerId;
   currentPoint->get_PointerId(&pointerId);
   nsRefPtr<Touch> touch = CreateDOMTouch(currentPoint.Get());
   touch->mChanged = true;
   mTouches.Put(pointerId, touch);
   WidgetTouchEvent* touchEvent =
     new WidgetTouchEvent(true, NS_TOUCH_START, mWidget.Get());
   if (mTouches.Count() == 1) {
     // If this is the first touchstart of a touch session reset some
     // tracking flags.
     mContentConsumingTouch = false;
     mApzConsumingTouch = false;
     mRecognizerWantsEvents = true;
     mCancelable = true;
     mCanceledIds.Clear();
   } else {
     mCancelable = false;
   }
   InitTouchEventTouchList(touchEvent);
   DispatchAsyncTouchEvent(touchEvent);
   if (ShouldDeliverInputToRecognizer()) {
     mGestureRecognizer->ProcessDownEvent(currentPoint.Get());
   }
   return S_OK;
 }
 void
 MetroInput::AddPointerMoveDataToRecognizer(UI::Core::IPointerEventArgs* aArgs)
 {
   if (ShouldDeliverInputToRecognizer()) {
     WRL::ComPtr<Foundation::Collections::IVector<UI::Input::PointerPoint*>>
         pointerPoints;
     aArgs->GetIntermediatePoints(pointerPoints.GetAddressOf());
     mGestureRecognizer->ProcessMoveEvents(pointerPoints.Get());
   }
 }
 // This event is raised when the user moves the mouse, moves a pen that is
 // in contact with the surface, or moves a finger that is in contact with
 // a touch screen.
 HRESULT
 MetroInput::OnPointerMoved(UI::Core::ICoreWindow* aSender,
                            UI::Core::IPointerEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WRL::ComPtr<UI::Input::IPointerPoint> currentPoint;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_CurrentPoint(currentPoint.GetAddressOf());
   currentPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   // For mouse and pen input, simply call our helper function
   if (deviceType !=
           Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     OnPointerNonTouch(currentPoint.Get());
     AddPointerMoveDataToRecognizer(aArgs);
     return S_OK;
   }
   // This is touch input.
   UpdateInputLevel(LEVEL_IMPRECISE);
   // Get the touch associated with this touch point.
   uint32_t pointerId;
   currentPoint->get_PointerId(&pointerId);
   nsRefPtr<Touch> touch = mTouches.Get(pointerId);
   // Some old drivers cause us to receive a PointerMoved event for a touchId
   // after we've already received a PointerReleased event for that touchId.
   // To work around those busted drivers, we simply ignore TouchMoved events
   // for touchIds that we are not currently tracking.  See bug 819223.
   if (!touch) {
     return S_OK;
   }
   AddPointerMoveDataToRecognizer(aArgs);
   // If the point hasn't moved, filter it out per the spec. Pres shell does
   // this as well, but we need to know when our first touchmove is going to
   // get delivered so we can check the result.
   if (!HasPointMoved(touch, currentPoint.Get())) {
     return S_OK;
   }
   touch = CreateDOMTouch(currentPoint.Get());
   touch->mChanged = true;
   // replacing old touch point in mTouches map
   mTouches.Put(pointerId, touch);
   WidgetTouchEvent* touchEvent =
     new WidgetTouchEvent(true, NS_TOUCH_MOVE, mWidget.Get());
   InitTouchEventTouchList(touchEvent);
   DispatchAsyncTouchEvent(touchEvent);
   return S_OK;
 }
 // This event is raised when the user lifts the left mouse button, lifts a
 // pen from the surface, or lifts her/his finger from a touch screen.
 HRESULT
 MetroInput::OnPointerReleased(UI::Core::ICoreWindow* aSender,
                               UI::Core::IPointerEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WRL::ComPtr<UI::Input::IPointerPoint> currentPoint;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_CurrentPoint(currentPoint.GetAddressOf());
   currentPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   // For mouse and pen input, simply call our helper function
   if (deviceType !=
           Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     OnPointerNonTouch(currentPoint.Get());
     mGestureRecognizer->ProcessUpEvent(currentPoint.Get());
     return S_OK;
   }
   // This is touch input.
   UpdateInputLevel(LEVEL_IMPRECISE);
   // Get the touch associated with this touch point.
   uint32_t pointerId;
   currentPoint->get_PointerId(&pointerId);
   nsRefPtr<Touch> touch = mTouches.Get(pointerId);
   // Purge any pending moves for this pointer
   if (touch->mChanged) {
     WidgetTouchEvent* touchEvent =
       new WidgetTouchEvent(true, NS_TOUCH_MOVE, mWidget.Get());
     InitTouchEventTouchList(touchEvent);
     DispatchAsyncTouchEvent(touchEvent);
   }
   // Remove this touch point from our map. Eventually all touch points are
   // removed for this session since we receive released events for every
   // point.
   mTouches.Remove(pointerId);
   // touchend events only have a single touch; the touch that has been removed
   WidgetTouchEvent* touchEvent =
     new WidgetTouchEvent(true, NS_TOUCH_END, mWidget.Get());
   touchEvent->touches.AppendElement(CreateDOMTouch(currentPoint.Get()));
   DispatchAsyncTouchEvent(touchEvent);
   if (ShouldDeliverInputToRecognizer()) {
     mGestureRecognizer->ProcessUpEvent(currentPoint.Get());
   }
   return S_OK;
 }
 // Tests for chrome vs. content target so we know whether input coordinates need
 // to be transformed through the apz. Eventually this hit testing should move
 // into the apz (bug 918288).
 bool
 MetroInput::HitTestChrome(const LayoutDeviceIntPoint& pt)
 {
   // Confirm this event targets content. We pick this up in browser's input.js.
   WidgetMouseEvent hittest(true, NS_MOUSE_MOZHITTEST, mWidget.Get(),
                            WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
   hittest.refPoint = pt;
   nsEventStatus status;
   mWidget->DispatchEvent(&hittest, status);
   return (status == nsEventStatus_eConsumeNoDefault);
 }
 /**
  * Returns true if the position is in chrome, false otherwise.
  */
 bool
 MetroInput::TransformRefPoint(const Foundation::Point& aPosition, LayoutDeviceIntPoint& aRefPointOut)
 {
   // If this event is destined for content we need to transform our ref point through
   // the apz so that zoom can be accounted for.
   aRefPointOut = LayoutDeviceIntPoint::FromUntyped(MetroUtils::LogToPhys(aPosition));
   ScreenIntPoint spt;
   spt.x = aRefPointOut.x;
   spt.y = aRefPointOut.y;
   // This is currently a general contained rect hit test, it may produce a false positive for
   // overlay chrome elements.
   bool apzIntersect = mWidget->ApzHitTest(spt);
   if (!apzIntersect) {
     return true;
   }
   if (HitTestChrome(aRefPointOut)) {
     return true;
   }
   mWidget->ApzTransformGeckoCoordinate(spt, &aRefPointOut);
   return false;
 }
 void
 MetroInput::TransformTouchEvent(WidgetTouchEvent* aEvent)
 {
   nsTArray< nsRefPtr<dom::Touch> >& touches = aEvent->touches;
   for (uint32_t i = 0; i < touches.Length(); ++i) {
     dom::Touch* touch = touches[i];
     if (touch) {
       LayoutDeviceIntPoint lpt;
       ScreenIntPoint spt;
       spt.x = touch->mRefPoint.x;
       spt.y = touch->mRefPoint.y;
       mWidget->ApzTransformGeckoCoordinate(spt, &lpt);
       touch->mRefPoint.x = lpt.x;
       touch->mRefPoint.y = lpt.y;
     }
   }
 }
 void
 MetroInput::InitGeckoMouseEventFromPointerPoint(
                                   WidgetMouseEvent* aEvent,
                                   UI::Input::IPointerPoint* aPointerPoint)
 {
   NS_ASSERTION(aPointerPoint, "InitGeckoMouseEventFromPointerPoint "
                               "called with null PointerPoint!");
   WRL::ComPtr<UI::Input::IPointerPointProperties> props;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   Foundation::Point position;
   uint64_t timestamp;
   float pressure;
   boolean canBeDoubleTap;
   float tiltX;
   float tiltY;
   aPointerPoint->get_Position(&position);
   aPointerPoint->get_Timestamp(&timestamp);
   aPointerPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   aPointerPoint->get_Properties(props.GetAddressOf());
   aPointerPoint->get_PointerId(&aEvent->pointerId);
   props->get_Pressure(&pressure);
   props->get_XTilt(&tiltX);
   props->get_YTilt(&tiltY);
   mGestureRecognizer->CanBeDoubleTap(aPointerPoint, &canBeDoubleTap);
   TransformRefPoint(position, aEvent->refPoint);
   if (!canBeDoubleTap) {
     aEvent->clickCount = 1;
   } else {
     aEvent->clickCount = 2;
   }
   aEvent->pressure = pressure;
   aEvent->tiltX = tiltX;
   aEvent->tiltY = tiltY;
   aEvent->buttons = ButtonsForPointerPoint(aPointerPoint);
   MozInputSourceFromDeviceType(deviceType, aEvent->inputSource);
 }
 // This event is raised when a precise pointer moves into the bounding box of
 // our window.  For touch input, this will be raised before the PointerPressed
 // event.
 HRESULT
 MetroInput::OnPointerEntered(UI::Core::ICoreWindow* aSender,
                              UI::Core::IPointerEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WRL::ComPtr<UI::Input::IPointerPoint> currentPoint;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_CurrentPoint(currentPoint.GetAddressOf());
   currentPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   // We only dispatch mouseenter and mouseexit events for mouse and pen input.
   if (deviceType !=
           Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     WidgetMouseEvent* event =
       new WidgetMouseEvent(true, NS_MOUSE_ENTER, mWidget.Get(),
                            WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
     UpdateInputLevel(LEVEL_PRECISE);
     InitGeckoMouseEventFromPointerPoint(event, currentPoint.Get());
     DispatchAsyncEventIgnoreStatus(event);
     return S_OK;
   }
   UpdateInputLevel(LEVEL_IMPRECISE);
   return S_OK;
 }
 // This event is raised when a precise pointer leaves the bounding box of
 // our window.  For touch input, this will be raised before the
 // PointerReleased event.
 HRESULT
 MetroInput::OnPointerExited(UI::Core::ICoreWindow* aSender,
                             UI::Core::IPointerEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   WRL::ComPtr<UI::Input::IPointerPoint> currentPoint;
   WRL::ComPtr<Devices::Input::IPointerDevice> device;
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_CurrentPoint(currentPoint.GetAddressOf());
   currentPoint->get_PointerDevice(device.GetAddressOf());
   device->get_PointerDeviceType(&deviceType);
   // We only dispatch mouseenter and mouseexit events for mouse and pen input.
   if (deviceType !=
           Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     WidgetMouseEvent* event =
       new WidgetMouseEvent(true, NS_MOUSE_EXIT, mWidget.Get(),
                            WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
     UpdateInputLevel(LEVEL_PRECISE);
     InitGeckoMouseEventFromPointerPoint(event, currentPoint.Get());
     DispatchAsyncEventIgnoreStatus(event);
     return S_OK;
   }
   UpdateInputLevel(LEVEL_IMPRECISE);
   return S_OK;
 }
 // Gecko expects a "finished" event to be sent that has the cumulative
 // changes since the gesture began.  The idea is that consumers could hook
 // only this last event and still effectively support magnification and
 // rotation. We accomplish sending this "finished" event by calling our
 // helper function with a cumulative "delta" value.
 //
 // After sending the "finished" event, this function detects and sends
 // swipe gestures.
 HRESULT
 MetroInput::OnManipulationCompleted(
                         UI::Input::IGestureRecognizer* aSender,
                         UI::Input::IManipulationCompletedEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_PointerDeviceType(&deviceType);
   if (deviceType ==
               Devices::Input::PointerDeviceType::PointerDeviceType_Mouse) {
     return S_OK;
   }
   UI::Input::ManipulationDelta delta;
   Foundation::Point position;
   aArgs->get_Position(&position);
   aArgs->get_Cumulative(&delta);
   // We check that the distance the user's finger traveled and the
   // velocity with which it traveled exceed our thresholds for
   // classifying the movement as a swipe.
   UI::Input::ManipulationVelocities velocities;
   aArgs->get_Velocities(&velocities);
   bool isHorizontalSwipe =
             abs(velocities.Linear.X) >= SWIPE_MIN_VELOCITY
          && abs(delta.Translation.X) >= SWIPE_MIN_DISTANCE;
   bool isVerticalSwipe =
             abs(velocities.Linear.Y) >= SWIPE_MIN_VELOCITY
          && abs(delta.Translation.Y) >= SWIPE_MIN_DISTANCE;
   // If our thresholds were exceeded for both a vertical and a horizontal
   // swipe, it means the user is flinging her/his finger around and we
   // should just ignore the input.
   if (isHorizontalSwipe && isVerticalSwipe) {
     return S_OK;
   }
   if (isHorizontalSwipe) {
     WidgetSimpleGestureEvent* swipeEvent =
       new WidgetSimpleGestureEvent(true, NS_SIMPLE_GESTURE_SWIPE,
                                    mWidget.Get());
     swipeEvent->direction = delta.Translation.X > 0
                          ? nsIDOMSimpleGestureEvent::DIRECTION_RIGHT
                          : nsIDOMSimpleGestureEvent::DIRECTION_LEFT;
     swipeEvent->delta = delta.Translation.X;
     swipeEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
     swipeEvent->refPoint = LayoutDeviceIntPoint::FromUntyped(MetroUtils::LogToPhys(position));
     DispatchAsyncEventIgnoreStatus(swipeEvent);
   }
   if (isVerticalSwipe) {
     WidgetSimpleGestureEvent* swipeEvent =
       new WidgetSimpleGestureEvent(true, NS_SIMPLE_GESTURE_SWIPE,
                                    mWidget.Get());
     swipeEvent->direction = delta.Translation.Y > 0
                          ? nsIDOMSimpleGestureEvent::DIRECTION_DOWN
                          : nsIDOMSimpleGestureEvent::DIRECTION_UP;
     swipeEvent->delta = delta.Translation.Y;
     swipeEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
     swipeEvent->refPoint = LayoutDeviceIntPoint::FromUntyped(MetroUtils::LogToPhys(position));
     DispatchAsyncEventIgnoreStatus(swipeEvent);
   }
   return S_OK;
 }
 // This event is raised when a sequence of pointer events has been
 // interpreted by the GestureRecognizer as a tap (this could be a mouse
 // click, a pen tap, or a tap on a touch surface).
 HRESULT
 MetroInput::OnTapped(UI::Input::IGestureRecognizer* aSender,
                      UI::Input::ITappedEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_PointerDeviceType(&deviceType);
   unsigned int tapCount;
   aArgs->get_TapCount(&tapCount);
   // For mouse and pen input, we send mousedown/mouseup/mousemove
   // events as soon as we detect the input event.  For touch input, a set of
   // mousedown/mouseup events will be sent only once a tap has been detected.
   if (deviceType != Devices::Input::PointerDeviceType::PointerDeviceType_Touch) {
     return S_OK;
   }
   Foundation::Point position;
   aArgs->get_Position(&position);
   HandleTap(position, tapCount);
   return S_OK;
 }
 // This event is raised when a sequence of pointer events has been
 // interpreted by the GestureRecognizer as a right tap.
 // This could be a mouse right-click, a right-click on a pen, or
 // a tap-and-hold on a touch surface.
 HRESULT
 MetroInput::OnRightTapped(UI::Input::IGestureRecognizer* aSender,
                           UI::Input::IRightTappedEventArgs* aArgs)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   Devices::Input::PointerDeviceType deviceType;
   aArgs->get_PointerDeviceType(&deviceType);
   Foundation::Point position;
   aArgs->get_Position(&position);
   HandleLongTap(position);
   return S_OK;
 }
 void
 MetroInput::HandleTap(const Foundation::Point& aPoint, unsigned int aTapCount)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   LayoutDeviceIntPoint refPoint;
   TransformRefPoint(aPoint, refPoint);
   WidgetMouseEvent* mouseEvent =
     new WidgetMouseEvent(true, NS_MOUSE_MOVE, mWidget.Get(),
                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
   mouseEvent->refPoint = refPoint;
   mouseEvent->clickCount = aTapCount;
   mouseEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
   DispatchAsyncEventIgnoreStatus(mouseEvent);
   mouseEvent =
     new WidgetMouseEvent(true, NS_MOUSE_BUTTON_DOWN, mWidget.Get(),
                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
   mouseEvent->refPoint = refPoint;
   mouseEvent->clickCount = aTapCount;
   mouseEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
   mouseEvent->button = WidgetMouseEvent::buttonType::eLeftButton;
   DispatchAsyncEventIgnoreStatus(mouseEvent);
   mouseEvent =
     new WidgetMouseEvent(true, NS_MOUSE_BUTTON_UP, mWidget.Get(),
                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
   mouseEvent->refPoint = refPoint;
   mouseEvent->clickCount = aTapCount;
   mouseEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
   mouseEvent->button = WidgetMouseEvent::buttonType::eLeftButton;
   DispatchAsyncEventIgnoreStatus(mouseEvent);
   // Make sure all gecko events are dispatched and the dom is up to date
   // so that when ui automation comes in looking for focus info it gets
   // the right information.
   MetroAppShell::MarkEventQueueForPurge();
 }
 void
 MetroInput::HandleLongTap(const Foundation::Point& aPoint)
 {
 #ifdef DEBUG_INPUT
   LogFunction();
 #endif
   LayoutDeviceIntPoint refPoint;
   TransformRefPoint(aPoint, refPoint);
   WidgetMouseEvent* contextEvent =
     new WidgetMouseEvent(true, NS_CONTEXTMENU, mWidget.Get(),
                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
   contextEvent->refPoint = refPoint;
   contextEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
   DispatchAsyncEventIgnoreStatus(contextEvent);
 }
 /**
  * Implementation Details
  */
 nsEventStatus MetroInput::sThrowawayStatus;
 void
 MetroInput::DispatchAsyncEventIgnoreStatus(WidgetInputEvent* aEvent)
 {
   aEvent->time = ::GetMessageTime();
   mModifierKeyState.Update();
   mModifierKeyState.InitInputEvent(*aEvent);
   mInputEventQueue.Push(aEvent);
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(this, &MetroInput::DeliverNextQueuedEventIgnoreStatus);
   NS_DispatchToCurrentThread(runnable);
 }
 void
 MetroInput::DeliverNextQueuedEventIgnoreStatus()
 {
   nsAutoPtr<WidgetGUIEvent> event =
     static_cast<WidgetGUIEvent*>(mInputEventQueue.PopFront());
   MOZ_ASSERT(event.get());
   DispatchEventIgnoreStatus(event.get());
   // Let app shell know we've delivered that last input we wanted purged
   // via a call to MarkEventQueueForPurge().
   if (event->message == NS_MOUSE_BUTTON_UP) {
     MetroAppShell::InputEventsDispatched();
   }
   // Clear :hover/:active states for mouse events generated by HandleTap
   WidgetMouseEvent* mouseEvent = event.get()->AsMouseEvent();
   if (!mouseEvent) {
     return;
   }
   if (mouseEvent->message != NS_MOUSE_BUTTON_UP ||
       mouseEvent->inputSource != nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
     return;
   }
   nsCOMPtr<nsIPresShell> presShell = mWidget->GetPresShell();
   if (presShell) {
     EventStateManager* esm = presShell->GetPresContext()->EventStateManager();
     if (esm) {
       esm->SetContentState(nullptr, NS_EVENT_STATE_HOVER);
     }
   }
 }
 void
 MetroInput::DispatchAsyncTouchEvent(WidgetTouchEvent* aEvent)
 {
   aEvent->time = ::GetMessageTime();
   mModifierKeyState.Update();
   mModifierKeyState.InitInputEvent(*aEvent);
   mInputEventQueue.Push(aEvent);
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(this, &MetroInput::DeliverNextQueuedTouchEvent);
   NS_DispatchToCurrentThread(runnable);
 }
 static void DumpTouchIds(const char* aTarget, WidgetTouchEvent* aEvent)
 {
   // comment out for touch moves
   if (aEvent->message == NS_TOUCH_MOVE) {
     return;
   }
   switch(aEvent->message) {
     case NS_TOUCH_START:
     WinUtils::Log("DumpTouchIds: NS_TOUCH_START block");
     break;
     case NS_TOUCH_MOVE:
     WinUtils::Log("DumpTouchIds: NS_TOUCH_MOVE block");
     break;
     case NS_TOUCH_END:
     WinUtils::Log("DumpTouchIds: NS_TOUCH_END block");
     break;
     case NS_TOUCH_CANCEL:
     WinUtils::Log("DumpTouchIds: NS_TOUCH_CANCEL block");
     break;
   }
   nsTArray< nsRefPtr<dom::Touch> >& touches = aEvent->touches;
   for (uint32_t i = 0; i < touches.Length(); ++i) {
     dom::Touch* touch = touches[i];
     if (!touch) {
       continue;
     }
     int32_t id = touch->Identifier();
     WinUtils::Log("   id=%d target=%s", id, aTarget);
   }
 }
 static void DumpTouchBehavior(nsTArray<uint32_t>& aBehavior)
 {
   WinUtils::Log("DumpTouchBehavior: Touch behavior flags set for current touch session:");
   for (uint32_t i = 0; i < aBehavior.Length(); i++) {
     if (mozilla::layers::AllowedTouchBehavior::VERTICAL_PAN & aBehavior[i]) {
       WinUtils::Log("VERTICAL_PAN");
     }
     if (mozilla::layers::AllowedTouchBehavior::HORIZONTAL_PAN & aBehavior[i]) {
       WinUtils::Log("HORIZONTAL_PAN");
     }
     if (mozilla::layers::AllowedTouchBehavior::UNKNOWN & aBehavior[i]) {
       WinUtils::Log("UNKNOWN");
     }
     if ((mozilla::layers::AllowedTouchBehavior::NONE & aBehavior[i]) == 0) {
       WinUtils::Log("NONE");
     }
   }
 }
 /*
  * nsPreShell's processing of WidgetTouchEvent events:
  *
  * NS_TOUCH_START:
  *  Interprets a single touch point as the first touch point of a block and will reset its
  *  queue when it receives this. For multiple touch points it sets all points in its queue
  *  and marks new points as changed.
  * NS_TOUCH_MOVE:
  *  Uses the equality tests in dom::Touch to test if a touch point has changed (moved).
  *  If a point has moved, keeps this touch point in the event, otherwise it removes
  *  the touch point. Note if no points have changed, it exits without sending a dom event.
  * NS_TOUCH_CANCEL/NS_TOUCH_END
  *  Assumes any point in touchEvent->touches has been removed or canceled.
 */
 //#define DUMP_TOUCH_IDS(aTarget, aEvent) DumpTouchIds(aTarget, aEvent)
 #define DUMP_TOUCH_IDS(...)
 //#define DUMP_ALLOWED_TOUCH_BEHAVIOR(aBehavior) DumpTouchBehavior(aBehavior)
 #define DUMP_ALLOWED_TOUCH_BEHAVIOR(...)
 void
 MetroInput::HandleFirstTouchStartEvent(WidgetTouchEvent* aEvent)
 {
   nsEventStatus contentStatus = nsEventStatus_eIgnore;
   WidgetTouchEvent transformedEvent(*aEvent);
   DUMP_TOUCH_IDS("APZC(1)", aEvent);
   mWidget->ApzReceiveInputEvent(&transformedEvent, &mTargetAPZCGuid);
   if (gTouchActionPropertyEnabled) {
     nsTArray<TouchBehaviorFlags> touchBehaviors;
     // Retrieving touch behaviors from apzctm and from the content (if needed)
     // then setting it back to the apzc. The apzc we retrieved touch behaviors
     // from and we're setting to may changes if there are multiple touches (in that
     // case apzctm needs to take common ancestor of them).
     GetAllowedTouchBehavior(&transformedEvent, touchBehaviors);
     // Setting the touch behaviors to the apzc that will be responsible
     // for interpreting it. It may be not the same apzc we retrieved touch
     // action values from. E.g. for zooming we're taking parent apzc of a few ones
     // that were touched but touch behaviors would be taken from childs.
     DUMP_ALLOWED_TOUCH_BEHAVIOR(touchBehaviors);
     mWidget->ApzcSetAllowedTouchBehavior(mTargetAPZCGuid, touchBehaviors);
     if (IsTouchBehaviorForbidden(touchBehaviors)) {
       mContentConsumingTouch = true;
     }
   }
   DUMP_TOUCH_IDS("DOM(2)", aEvent);
   mWidget->DispatchEvent(&transformedEvent, contentStatus);
   if (nsEventStatus_eConsumeNoDefault == contentStatus) {
     mContentConsumingTouch = true;
   }
   if (mContentConsumingTouch) {
     mCancelable = false;
     mWidget->ApzContentConsumingTouch(mTargetAPZCGuid);
     DispatchTouchCancel(aEvent);
   }
   // Disable gesture based events (taps, swipes, rotation) if
   // preventDefault is called on touchstart.
   mRecognizerWantsEvents = !(nsEventStatus_eConsumeNoDefault == contentStatus);
   // If content is consuming touch don't generate any gesture based
   // input - clear the recognizer state without sending any events.
   if (!ShouldDeliverInputToRecognizer()) {
     mGestureRecognizer->CompleteGesture();
   }
 }
 void
 MetroInput::HandleFirstTouchMoveEvent(WidgetTouchEvent* aEvent)
 {
   mCancelable = false;
   nsEventStatus contentStatus = nsEventStatus_eIgnore;
   nsEventStatus apzcStatus = nsEventStatus_eIgnore;
   WidgetTouchEvent transformedEvent(*aEvent);
   DUMP_TOUCH_IDS("APZC(2)", aEvent);
   apzcStatus = mWidget->ApzReceiveInputEvent(&transformedEvent, &mTargetAPZCGuid);
   // We need to dispatch here only touch event, not pointer one.
   // That's because according to the spec pointer events doesn't imply pointermove event
   // between pointerdown and pointercancel (If default touch behavior is triggered).
   // But at the same time we need to dispatch at least touchmove event to let content to
   // consume it (or not consume).
   // TODO: determine how to dispatch only one kind of events: currently there are two options:
   // 1) Create two separate instances of the WidgetTouchEvent and WidgetPointerEvent and
   // dispatch them separately.
   // 2) Add a boolean flag to the WidgetTouchEvent that states whether this event should produce
   // both touch and pointer event or only touch one.
   // Anyway it's worth to add this stuff only after patches from bug 822898 (Pointer events) are
   // fully commited.
   DUMP_TOUCH_IDS("DOM(3)", aEvent);
   mWidget->DispatchEvent(&transformedEvent, contentStatus);
   // Checking content result first since content can override apzc wish and disallow apzc touch
   // behavior (via preventDefault).
   if (nsEventStatus_eConsumeNoDefault == contentStatus) {
     // Touchmove handler consumed touch.
     mContentConsumingTouch = true;
   } else if (nsEventStatus_eConsumeNoDefault == apzcStatus) {
     // Apzc triggered default behavior.
     mApzConsumingTouch = true;
   }
   // Let the apz know if content wants to consume touch events, or cancel
   // the touch block for content.
   if (mContentConsumingTouch) {
     mWidget->ApzContentConsumingTouch(mTargetAPZCGuid);
     DispatchTouchCancel(aEvent);
   } else {
     mWidget->ApzContentIgnoringTouch(mTargetAPZCGuid);
   }
   if (mApzConsumingTouch) {
     // Dispatching cancel to the content.
     DispatchTouchCancel(&transformedEvent);
   }
 }
 void
 MetroInput::DeliverNextQueuedTouchEvent()
 {
   /*
    * We go through states here and make different decisions in each:
    *
    * 1) Hit test for apz on first touchstart
    *  If non-apzc content/chrome is the target simplify event delivery from
    *  that point on by directing all input to chrome, bypassing the apz.
    * 2) Process first touchstart and touchmove events
    *  If touch behavior value associated with the TouchStart's touches doesn't
    *  allow zooming or panning we explicitly set mContentConsumingTouch to true.
    *  Otherwise check the result and set mContentConsumingTouch appropriately.
    *  Deliver touch events to the apz (ignoring return result) and to content.
    * 3) If mContentConsumingTouch is true: deliver touch to content after
    *  transforming through the apz. Also let the apz know content is
    *  consuming touch and deliver cancel event to apz.
    * 4) If mContentConsumingTouch is false: check the result from the apz and
    *  set mApzConsumingTouch appropriately.
    * 5) If mApzConsumingTouch is true: send a touchcancel to content
    *  and deliver all events to the apz. If the apz is doing something with
    *  the events we can save ourselves the overhead of delivering dom events.
    *
    * Notes:
    * - never rely on the contents of mTouches here, since this is a delayed
    *   callback. mTouches will likely have been modified.
    */
   nsEventStatus status = nsEventStatus_eIgnore;
   WidgetTouchEvent* event =
     static_cast<WidgetTouchEvent*>(mInputEventQueue.PopFront());
   MOZ_ASSERT(event);
   AutoDeleteEvent wrap(event);
   // Test for non-apz vs. apz target. To do this we only use the first touch
   // point since that will be the input batch target. Cache this for touch events
   // since HitTestChrome has to send a dom event.
   if (mCancelable && event->message == NS_TOUCH_START) {
     nsRefPtr<Touch> touch = event->touches[0];
     LayoutDeviceIntPoint pt = LayoutDeviceIntPoint::FromUntyped(touch->mRefPoint);
     // This is currently a general contained rect hit test, it may produce a false
     // positive for overlay chrome elements. Also, some content pages won't support
     // apzc, so this may be false for content as well.
     bool apzIntersect = mWidget->ApzHitTest(mozilla::ScreenIntPoint(pt.x, pt.y));
     mNonApzTargetForTouch = (!apzIntersect || HitTestChrome(pt));
   }
   // If this event is destined for dom, deliver it directly there bypassing
   // the apz.
   if (mNonApzTargetForTouch) {
     DUMP_TOUCH_IDS("DOM(1)", event);
     mWidget->DispatchEvent(event, status);
     if (mCancelable) {
       // Disable gesture based events (taps, swipes, rotation) if
       // preventDefault is called on touchstart.
       if (nsEventStatus_eConsumeNoDefault == status) {
         mRecognizerWantsEvents = false;
         mGestureRecognizer->CompleteGesture();
       }
       if (event->message == NS_TOUCH_MOVE) {
         mCancelable = false;
       }
     }
     return;
   }
   if (mCancelable && event->message == NS_TOUCH_START) {
     HandleFirstTouchStartEvent(event);
     return;
   } else if (mCancelable && event->message == NS_TOUCH_MOVE) {
     HandleFirstTouchMoveEvent(event);
     return;
   }
   // Let TouchEnd events go through even if mCancelable is true since we
   // don't need to check whether it is prevented by content or consumed
   // by apzc.
   // If content is consuming touch, we may need to transform event coords
   // through the apzc before sending to the dom. Otherwise send the event
   // to apzc.
   if (mContentConsumingTouch) {
     // Only translate if we're dealing with web content that's transformed
     // by the apzc.
     TransformTouchEvent(event);
     DUMP_TOUCH_IDS("DOM(4)", event);
     mWidget->DispatchEvent(event, status);
     return;
   }
   DUMP_TOUCH_IDS("APZC(3)", event);
   status = mWidget->ApzReceiveInputEvent(event, nullptr);
   // If we're getting a new touch (touch start) after some touch start/move
   // events we need to reset touch behavior for touches.
   if (gTouchActionPropertyEnabled && event->message == NS_TOUCH_START) {
     nsTArray<TouchBehaviorFlags> touchBehaviors;
     GetAllowedTouchBehavior(event, touchBehaviors);
     DUMP_ALLOWED_TOUCH_BEHAVIOR(touchBehaviors);
     mWidget->ApzcSetAllowedTouchBehavior(mTargetAPZCGuid, touchBehaviors);
   }
   // Send the event to content unless APZC is consuming it.
   if (!mApzConsumingTouch) {
     if (status == nsEventStatus_eConsumeNoDefault) {
       mApzConsumingTouch = true;
       DispatchTouchCancel(event);
       return;
     }
     TransformTouchEvent(event);
     DUMP_TOUCH_IDS("DOM(5)", event);
     mWidget->DispatchEvent(event, status);
   }
 }
 void
 MetroInput::DispatchTouchCancel(WidgetTouchEvent* aEvent)
 {
   MOZ_ASSERT(aEvent);
   // Send a touchcancel for each pointer id we have a corresponding start
   // for. Note we can't rely on mTouches here since touchends remove points
   // from it.
   WidgetTouchEvent touchEvent(true, NS_TOUCH_CANCEL, mWidget.Get());
   nsTArray< nsRefPtr<dom::Touch> >& touches = aEvent->touches;
   for (uint32_t i = 0; i < touches.Length(); ++i) {
     dom::Touch* touch = touches[i];
     if (!touch) {
       continue;
     }
     int32_t id = touch->Identifier();
     if (mCanceledIds.Contains(id)) {
       continue;
     }
     mCanceledIds.AppendElement(id);
     touchEvent.touches.AppendElement(touch);
   }
   if (!touchEvent.touches.Length()) {
     return;
   }
   if (mContentConsumingTouch) {
     DUMP_TOUCH_IDS("APZC(4)", &touchEvent);
     mWidget->ApzReceiveInputEvent(&touchEvent, nullptr);
   } else {
     DUMP_TOUCH_IDS("DOM(6)", &touchEvent);
     mWidget->DispatchEvent(&touchEvent, sThrowawayStatus);
   }
 }
 void
 MetroInput::DispatchEventIgnoreStatus(WidgetGUIEvent *aEvent)
 {
   mWidget->DispatchEvent(aEvent, sThrowawayStatus);
 }
 void
 MetroInput::UnregisterInputEvents() {
   // Unregister ourselves for the edge swipe event
   WRL::ComPtr<UI::Input::IEdgeGestureStatics> edgeStatics;
   if (SUCCEEDED(Foundation::GetActivationFactory(
         WRL::Wrappers::HStringReference(
               RuntimeClass_Windows_UI_Input_EdgeGesture).Get(),
       edgeStatics.GetAddressOf()))) {
     WRL::ComPtr<UI::Input::IEdgeGesture> edge;
     if (SUCCEEDED(edgeStatics->GetForCurrentView(edge.GetAddressOf()))) {
       edge->remove_Starting(mTokenEdgeStarted);
       edge->remove_Canceled(mTokenEdgeCanceled);
       edge->remove_Completed(mTokenEdgeCompleted);
     }
   }
   // Unregister ourselves from the window events. This is extremely important;
   // once this object is destroyed we don't want Windows to try to send events
   // to it.
   mWindow->remove_PointerPressed(mTokenPointerPressed);
   mWindow->remove_PointerReleased(mTokenPointerReleased);
   mWindow->remove_PointerMoved(mTokenPointerMoved);
   mWindow->remove_PointerEntered(mTokenPointerEntered);
   mWindow->remove_PointerExited(mTokenPointerExited);
   // Unregistering from the gesture recognizer events probably isn't as
   // necessary since we're about to destroy the gesture recognizer, but
   // it can't hurt.
   mGestureRecognizer->remove_ManipulationCompleted(
                                         mTokenManipulationCompleted);
   mGestureRecognizer->remove_Tapped(mTokenTapped);
   mGestureRecognizer->remove_RightTapped(mTokenRightTapped);
 }
 void
 MetroInput::RegisterInputEvents()
 {
   NS_ASSERTION(mWindow, "Must have a window to register for input events!");
   NS_ASSERTION(mGestureRecognizer,
                "Must have a GestureRecognizer for input events!");
   // Register for edge swipe
   WRL::ComPtr<UI::Input::IEdgeGestureStatics> edgeStatics;
   Foundation::GetActivationFactory(
             WRL::Wrappers::HStringReference(
                     RuntimeClass_Windows_UI_Input_EdgeGesture)
             .Get(),
             edgeStatics.GetAddressOf());
   WRL::ComPtr<UI::Input::IEdgeGesture> edge;
   edgeStatics->GetForCurrentView(edge.GetAddressOf());
   edge->add_Starting(
       WRL::Callback<EdgeGestureHandler>(
                                   this,
                                   &MetroInput::OnEdgeGestureStarted).Get(),
       &mTokenEdgeStarted);
   edge->add_Canceled(
       WRL::Callback<EdgeGestureHandler>(
                                   this,
                                   &MetroInput::OnEdgeGestureCanceled).Get(),
       &mTokenEdgeCanceled);
   edge->add_Completed(
       WRL::Callback<EdgeGestureHandler>(
                                   this,
                                   &MetroInput::OnEdgeGestureCompleted).Get(),
       &mTokenEdgeCompleted);
   // Set up our Gesture Recognizer to raise events for the gestures we
   // care about
   mGestureRecognizer->put_GestureSettings(
             UI::Input::GestureSettings::GestureSettings_Tap
           | UI::Input::GestureSettings::GestureSettings_DoubleTap
           | UI::Input::GestureSettings::GestureSettings_RightTap
           | UI::Input::GestureSettings::GestureSettings_Hold
           | UI::Input::GestureSettings::GestureSettings_ManipulationTranslateX
           | UI::Input::GestureSettings::GestureSettings_ManipulationTranslateY);
   // Register for the pointer events on our Window
   mWindow->add_PointerPressed(
       WRL::Callback<PointerEventHandler>(
         this,
         &MetroInput::OnPointerPressed).Get(),
       &mTokenPointerPressed);
   mWindow->add_PointerReleased(
       WRL::Callback<PointerEventHandler>(
         this,
         &MetroInput::OnPointerReleased).Get(),
       &mTokenPointerReleased);
   mWindow->add_PointerMoved(
       WRL::Callback<PointerEventHandler>(
         this,
         &MetroInput::OnPointerMoved).Get(),
       &mTokenPointerMoved);
   mWindow->add_PointerEntered(
       WRL::Callback<PointerEventHandler>(
         this,
         &MetroInput::OnPointerEntered).Get(),
       &mTokenPointerEntered);
   mWindow->add_PointerExited(
       WRL::Callback<PointerEventHandler>(
         this,
         &MetroInput::OnPointerExited).Get(),
       &mTokenPointerExited);
   // Register for the events raised by our Gesture Recognizer
   mGestureRecognizer->add_Tapped(
       WRL::Callback<TappedEventHandler>(
         this,
         &MetroInput::OnTapped).Get(),
       &mTokenTapped);
   mGestureRecognizer->add_RightTapped(
       WRL::Callback<RightTappedEventHandler>(
         this,
         &MetroInput::OnRightTapped).Get(),
       &mTokenRightTapped);
   mGestureRecognizer->add_ManipulationCompleted(
       WRL::Callback<ManipulationCompletedEventHandler>(
         this,
         &MetroInput::OnManipulationCompleted).Get(),
       &mTokenManipulationCompleted);
 }
 } } }

The Tor Browser / annotate

widget/windows/winrt/MetroInput.cpp@ac0c01689b40 (annotated)

widget/windows/winrt/MetroInput.cpp