dom/events/TouchEvent.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/Navigator.h"
   8 #include "mozilla/dom/TouchEvent.h"
   9 #include "mozilla/dom/Touch.h"
  10 #include "mozilla/dom/TouchListBinding.h"
  11 #include "mozilla/BasePrincipal.h"
  12 #include "mozilla/LookAndFeel.h"
  13 #include "mozilla/Preferences.h"
  14 #include "mozilla/StaticPrefs_dom.h"
  15 #include "mozilla/TouchEvents.h"
  16 #include "nsContentUtils.h"
  17 #include "nsIDocShell.h"
  18 #include "nsExceptionHandler.h"
  19
  20 namespace mozilla::dom {
  21
  22 /******************************************************************************
  23  * TouchList
  24  *****************************************************************************/
  25
  26 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TouchList)
  27   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  28   NS_INTERFACE_MAP_ENTRY(nsISupports)
  29 NS_INTERFACE_MAP_END
  30
  31 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(TouchList, mParent, mPoints)
  32
  33 NS_IMPL_CYCLE_COLLECTING_ADDREF(TouchList)
  34 NS_IMPL_CYCLE_COLLECTING_RELEASE(TouchList)
  35
  36 JSObject* TouchList::WrapObject(JSContext* aCx,
  37                                 JS::Handle<JSObject*> aGivenProto) {
  38   return TouchList_Binding::Wrap(aCx, this, aGivenProto);
  39 }
  40
  41 // static
  42 bool TouchList::PrefEnabled(JSContext* aCx, JSObject* aGlobal) {
  43   return TouchEvent::PrefEnabled(aCx, aGlobal);
  44 }
  45
  46 /******************************************************************************
  47  * TouchEvent
  48  *****************************************************************************/
  49
  50 TouchEvent::TouchEvent(EventTarget* aOwner, nsPresContext* aPresContext,
  51                        WidgetTouchEvent* aEvent)
  52     : UIEvent(
  53           aOwner, aPresContext,
  54           aEvent ? aEvent : new WidgetTouchEvent(false, eVoidEvent, nullptr)) {
  55   if (aEvent) {
  56     mEventIsInternal = false;
  57
  58     for (uint32_t i = 0; i < aEvent->mTouches.Length(); ++i) {
  59       Touch* touch = aEvent->mTouches[i];
  60       touch->InitializePoints(mPresContext, aEvent);
  61     }
  62   } else {
  63     mEventIsInternal = true;
  64   }
  65 }
  66
  67 NS_IMPL_CYCLE_COLLECTION_INHERITED(TouchEvent, UIEvent,
  68                                    mEvent->AsTouchEvent()->mTouches, mTouches,
  69                                    mTargetTouches, mChangedTouches)
  70
  71 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TouchEvent)
  72 NS_INTERFACE_MAP_END_INHERITING(UIEvent)
  73
  74 NS_IMPL_ADDREF_INHERITED(TouchEvent, UIEvent)
  75 NS_IMPL_RELEASE_INHERITED(TouchEvent, UIEvent)
  76
  77 void TouchEvent::InitTouchEvent(const nsAString& aType, bool aCanBubble,
  78                                 bool aCancelable, nsGlobalWindowInner* aView,
  79                                 int32_t aDetail, bool aCtrlKey, bool aAltKey,
  80                                 bool aShiftKey, bool aMetaKey,
  81                                 TouchList* aTouches, TouchList* aTargetTouches,
  82                                 TouchList* aChangedTouches) {
  83   NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
  84
  85   UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, aDetail);
  86   mEvent->AsInputEvent()->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey,
  87                                              aMetaKey);
  88
  89   mEvent->AsTouchEvent()->mTouches.Clear();
  90
  91   // To support touch.target retargeting also when the event is
  92   // created by JS, we need to copy Touch objects to the widget event.
  93   // In order to not affect targetTouches, we don't check duplicates in that
  94   // list.
  95   mTargetTouches = aTargetTouches;
  96   AssignTouchesToWidgetEvent(mTargetTouches, false);
  97   mTouches = aTouches;
  98   AssignTouchesToWidgetEvent(mTouches, true);
  99   mChangedTouches = aChangedTouches;
 100   AssignTouchesToWidgetEvent(mChangedTouches, true);
 101 }
 102
 103 void TouchEvent::AssignTouchesToWidgetEvent(TouchList* aList,
 104                                             bool aCheckDuplicates) {
 105   if (!aList) {
 106     return;
 107   }
 108   WidgetTouchEvent* widgetTouchEvent = mEvent->AsTouchEvent();
 109   for (uint32_t i = 0; i < aList->Length(); ++i) {
 110     Touch* touch = aList->Item(i);
 111     if (touch &&
 112         (!aCheckDuplicates || !widgetTouchEvent->mTouches.Contains(touch))) {
 113       widgetTouchEvent->mTouches.AppendElement(touch);
 114     }
 115   }
 116 }
 117
 118 TouchList* TouchEvent::Touches() {
 119   if (!mTouches) {
 120     WidgetTouchEvent* touchEvent = mEvent->AsTouchEvent();
 121     if (mEvent->mMessage == eTouchEnd || mEvent->mMessage == eTouchCancel) {
 122       // for touchend events, remove any changed touches from mTouches
 123       WidgetTouchEvent::AutoTouchArray unchangedTouches;
 124       const WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
 125       for (uint32_t i = 0; i < touches.Length(); ++i) {
 126         if (!touches[i]->mChanged) {
 127           unchangedTouches.AppendElement(touches[i]);
 128         }
 129       }
 130       mTouches = new TouchList(ToSupports(this), unchangedTouches);
 131     } else {
 132       mTouches = new TouchList(ToSupports(this), touchEvent->mTouches);
 133     }
 134   }
 135   return mTouches;
 136 }
 137
 138 TouchList* TouchEvent::TargetTouches() {
 139   if (!mTargetTouches || !mTargetTouches->Length()) {
 140     WidgetTouchEvent* touchEvent = mEvent->AsTouchEvent();
 141     if (!mTargetTouches) {
 142       mTargetTouches = new TouchList(ToSupports(this));
 143     }
 144     const WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
 145     for (uint32_t i = 0; i < touches.Length(); ++i) {
 146       // for touchend/cancel events, don't append to the target list if this is
 147       // a touch that is ending
 148       if ((mEvent->mMessage != eTouchEnd && mEvent->mMessage != eTouchCancel) ||
 149           !touches[i]->mChanged) {
 150         bool equalTarget = touches[i]->mTarget == mEvent->mTarget;
 151         if (!equalTarget) {
 152           // Need to still check if we're inside native anonymous content
 153           // and the non-NAC target would be the same.
 154           nsIContent* touchTarget =
 155               nsIContent::FromEventTargetOrNull(touches[i]->mTarget);
 156           nsIContent* eventTarget =
 157               nsIContent::FromEventTargetOrNull(mEvent->mTarget);
 158           equalTarget = touchTarget && eventTarget &&
 159                         touchTarget->FindFirstNonChromeOnlyAccessContent() ==
 160                             eventTarget->FindFirstNonChromeOnlyAccessContent();
 161         }
 162         if (equalTarget) {
 163           mTargetTouches->Append(touches[i]);
 164         }
 165       }
 166     }
 167   }
 168   return mTargetTouches;
 169 }
 170
 171 TouchList* TouchEvent::ChangedTouches() {
 172   if (!mChangedTouches) {
 173     WidgetTouchEvent::AutoTouchArray changedTouches;
 174     WidgetTouchEvent* touchEvent = mEvent->AsTouchEvent();
 175     const WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
 176     for (uint32_t i = 0; i < touches.Length(); ++i) {
 177       if (touches[i]->mChanged) {
 178         changedTouches.AppendElement(touches[i]);
 179       }
 180     }
 181     mChangedTouches = new TouchList(ToSupports(this), changedTouches);
 182   }
 183   return mChangedTouches;
 184 }
 185
 186 // static
 187 bool TouchEvent::PrefEnabled(JSContext* aCx, JSObject* aGlobal) {
 188   nsIDocShell* docShell = nullptr;
 189   if (aGlobal) {
 190     nsGlobalWindowInner* win = xpc::WindowOrNull(aGlobal);
 191     if (win) {
 192       docShell = win->GetDocShell();
 193     }
 194   }
 195   return PrefEnabled(docShell);
 196 }
 197
 198 static bool PlatformSupportsTouch() {
 199   // Touch events are only actually supported if APZ is enabled. If APZ is
 200   // disabled globally, we can check that once and incorporate that into the
 201   // cached state. If APZ is enabled, we need to further check based on the
 202   // widget, which we do in PrefEnabled (and don't cache that result).
 203   static bool sIsTouchDeviceSupportPresent =
 204       !!LookAndFeel::GetInt(LookAndFeel::IntID::TouchDeviceSupportPresent) &&
 205       gfxPlatform::AsyncPanZoomEnabled();
 206
 207   return sIsTouchDeviceSupportPresent;
 208 }
 209
 210 // static
 211 bool TouchEvent::PrefEnabled(nsIDocShell* aDocShell) {
 212   MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
 213
 214   auto touchEventsOverride = mozilla::dom::TouchEventsOverride::None;
 215   if (aDocShell) {
 216     if (BrowsingContext* bc = aDocShell->GetBrowsingContext()) {
 217       touchEventsOverride = bc->TouchEventsOverride();
 218     }
 219   }
 220
 221   bool enabled = false;
 222   if (touchEventsOverride == mozilla::dom::TouchEventsOverride::Enabled) {
 223     enabled = true;
 224   } else if (touchEventsOverride ==
 225              mozilla::dom::TouchEventsOverride::Disabled) {
 226     enabled = false;
 227   } else {
 228     const int32_t prefValue = StaticPrefs::dom_w3c_touch_events_enabled();
 229     if (prefValue == 2) {
 230       enabled = PlatformSupportsTouch();
 231
 232       static bool firstTime = true;
 233       // The touch screen data seems to be inaccurate in the parent process,
 234       // and we really need the crash annotation in child processes.
 235       if (firstTime && !XRE_IsParentProcess()) {
 236         CrashReporter::AnnotateCrashReport(
 237             CrashReporter::Annotation::HasDeviceTouchScreen, enabled);
 238         firstTime = false;
 239       }
 240
 241 #if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
 242       if (enabled && aDocShell) {
 243         // APZ might be disabled on this particular widget, in which case
 244         // TouchEvent support will also be disabled. Try to detect that.
 245         RefPtr<nsPresContext> pc = aDocShell->GetPresContext();
 246         if (pc) {
 247           nsCOMPtr<nsIWidget> widget = pc->GetRootWidget();
 248           if (widget) {
 249             enabled &= widget->AsyncPanZoomEnabled();
 250           }
 251         }
 252       }
 253 #endif
 254     } else {
 255       enabled = !!prefValue;
 256     }
 257   }
 258
 259   if (enabled) {
 260     nsContentUtils::InitializeTouchEventTable();
 261   }
 262   return enabled;
 263 }
 264
 265 // static
 266 bool TouchEvent::LegacyAPIEnabled(JSContext* aCx, JSObject* aGlobal) {
 267   nsIPrincipal* principal = nsContentUtils::SubjectPrincipal(aCx);
 268   bool isSystem = principal && principal->IsSystemPrincipal();
 269
 270   nsIDocShell* docShell = nullptr;
 271   if (aGlobal) {
 272     nsGlobalWindowInner* win = xpc::WindowOrNull(aGlobal);
 273     if (win) {
 274       docShell = win->GetDocShell();
 275     }
 276   }
 277   return LegacyAPIEnabled(docShell, isSystem);
 278 }
 279
 280 // static
 281 bool TouchEvent::LegacyAPIEnabled(nsIDocShell* aDocShell,
 282                                   bool aCallerIsSystem) {
 283   return (aCallerIsSystem ||
 284           StaticPrefs::dom_w3c_touch_events_legacy_apis_enabled() ||
 285           (aDocShell && aDocShell->GetBrowsingContext() &&
 286            aDocShell->GetBrowsingContext()->TouchEventsOverride() ==
 287                mozilla::dom::TouchEventsOverride::Enabled)) &&
 288          PrefEnabled(aDocShell);
 289 }
 290
 291 // static
 292 already_AddRefed<TouchEvent> TouchEvent::Constructor(
 293     const GlobalObject& aGlobal, const nsAString& aType,
 294     const TouchEventInit& aParam) {
 295   nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
 296   RefPtr<TouchEvent> e = new TouchEvent(t, nullptr, nullptr);
 297   bool trusted = e->Init(t);
 298   RefPtr<TouchList> touches = e->CopyTouches(aParam.mTouches);
 299   RefPtr<TouchList> targetTouches = e->CopyTouches(aParam.mTargetTouches);
 300   RefPtr<TouchList> changedTouches = e->CopyTouches(aParam.mChangedTouches);
 301   e->InitTouchEvent(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
 302                     aParam.mDetail, aParam.mCtrlKey, aParam.mAltKey,
 303                     aParam.mShiftKey, aParam.mMetaKey, touches, targetTouches,
 304                     changedTouches);
 305   e->SetTrusted(trusted);
 306   e->SetComposed(aParam.mComposed);
 307   return e.forget();
 308 }
 309
 310 already_AddRefed<TouchList> TouchEvent::CopyTouches(
 311     const Sequence<OwningNonNull<Touch>>& aTouches) {
 312   RefPtr<TouchList> list = new TouchList(GetParentObject());
 313   size_t len = aTouches.Length();
 314   for (size_t i = 0; i < len; ++i) {
 315     list->Append(aTouches[i]);
 316   }
 317   return list.forget();
 318 }
 319
 320 bool TouchEvent::AltKey() { return mEvent->AsTouchEvent()->IsAlt(); }
 321
 322 bool TouchEvent::MetaKey() { return mEvent->AsTouchEvent()->IsMeta(); }
 323
 324 bool TouchEvent::CtrlKey() { return mEvent->AsTouchEvent()->IsControl(); }
 325
 326 bool TouchEvent::ShiftKey() { return mEvent->AsTouchEvent()->IsShift(); }
 327
 328 }  // namespace mozilla::dom
 329
 330 using namespace mozilla;
 331 using namespace mozilla::dom;
 332
 333 already_AddRefed<TouchEvent> NS_NewDOMTouchEvent(EventTarget* aOwner,
 334                                                  nsPresContext* aPresContext,
 335                                                  WidgetTouchEvent* aEvent) {
 336   RefPtr<TouchEvent> it = new TouchEvent(aOwner, aPresContext, aEvent);
 337   return it.forget();
 338 }