dom/events/KeyboardEvent.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/KeyboardEvent.h"
   8
   9 #include "mozilla/BasicEvents.h"
  10 #include "mozilla/StaticPrefs_dom.h"
  11 #include "mozilla/TextEvents.h"
  12 #include "mozilla/dom/Document.h"
  13 #include "mozilla/LookAndFeel.h"
  14 #include "nsContentUtils.h"
  15 #include "nsIPrincipal.h"
  16 #include "nsRFPService.h"
  17 #include "prtime.h"
  18
  19 namespace mozilla::dom {
  20
  21 KeyboardEvent::KeyboardEvent(EventTarget* aOwner, nsPresContext* aPresContext,
  22                              WidgetKeyboardEvent* aEvent)
  23     : UIEvent(aOwner, aPresContext,
  24               aEvent ? aEvent
  25                      : new WidgetKeyboardEvent(false, eVoidEvent, nullptr)),
  26       mInitializedByJS(false),
  27       mInitializedByCtor(false),
  28       mInitializedWhichValue(0) {
  29   if (aEvent) {
  30     mEventIsInternal = false;
  31   } else {
  32     mEventIsInternal = true;
  33     mEvent->AsKeyboardEvent()->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
  34   }
  35 }
  36
  37 bool KeyboardEvent::IsMenuAccessKeyPressed() const {
  38   Modifiers mask = LookAndFeel::GetMenuAccessKeyModifiers();
  39   Modifiers modifiers = GetModifiersForMenuAccessKey();
  40   return mask != MODIFIER_SHIFT && (modifiers & mask) &&
  41          (modifiers & ~(mask | MODIFIER_SHIFT)) == 0;
  42 }
  43
  44 static constexpr Modifiers kPossibleModifiersForAccessKey =
  45     MODIFIER_SHIFT | MODIFIER_CONTROL | MODIFIER_ALT | MODIFIER_META;
  46
  47 Modifiers KeyboardEvent::GetModifiersForMenuAccessKey() const {
  48   const WidgetInputEvent* inputEvent = WidgetEventPtr()->AsInputEvent();
  49   MOZ_ASSERT(inputEvent);
  50   return inputEvent->mModifiers & kPossibleModifiersForAccessKey;
  51 }
  52
  53 bool KeyboardEvent::AltKey(CallerType aCallerType) {
  54   bool altState = mEvent->AsKeyboardEvent()->IsAlt();
  55
  56   if (!ShouldResistFingerprinting(aCallerType)) {
  57     return altState;
  58   }
  59
  60   // We need to give a spoofed state for Alt key since it could be used as a
  61   // modifier key in certain keyboard layout. For example, the '@' key for
  62   // German keyboard for MAC is Alt+L.
  63   return GetSpoofedModifierStates(Modifier::MODIFIER_ALT, altState);
  64 }
  65
  66 bool KeyboardEvent::CtrlKey(CallerType aCallerType) {
  67   // We don't spoof this key when privacy.resistFingerprinting
  68   // is enabled, because it is often used for command key
  69   // combinations in web apps.
  70   return mEvent->AsKeyboardEvent()->IsControl();
  71 }
  72
  73 bool KeyboardEvent::ShiftKey(CallerType aCallerType) {
  74   bool shiftState = mEvent->AsKeyboardEvent()->IsShift();
  75
  76   if (!ShouldResistFingerprinting(aCallerType)) {
  77     return shiftState;
  78   }
  79
  80   return GetSpoofedModifierStates(Modifier::MODIFIER_SHIFT, shiftState);
  81 }
  82
  83 bool KeyboardEvent::MetaKey() {
  84   // We don't spoof this key when privacy.resistFingerprinting
  85   // is enabled, because it is often used for command key
  86   // combinations in web apps.
  87   return mEvent->AsKeyboardEvent()->IsMeta();
  88 }
  89
  90 bool KeyboardEvent::Repeat() { return mEvent->AsKeyboardEvent()->mIsRepeat; }
  91
  92 bool KeyboardEvent::IsComposing() {
  93   return mEvent->AsKeyboardEvent()->mIsComposing;
  94 }
  95
  96 void KeyboardEvent::GetKey(nsAString& aKeyName) const {
  97   mEvent->AsKeyboardEvent()->GetDOMKeyName(aKeyName);
  98 }
  99
 100 void KeyboardEvent::GetCode(nsAString& aCodeName, CallerType aCallerType) {
 101   if (!ShouldResistFingerprinting(aCallerType)) {
 102     mEvent->AsKeyboardEvent()->GetDOMCodeName(aCodeName);
 103     return;
 104   }
 105
 106   // When fingerprinting resistance is enabled, we will give a spoofed code
 107   // according to the content-language of the document.
 108   nsCOMPtr<Document> doc = GetDocument();
 109
 110   nsRFPService::GetSpoofedCode(doc, mEvent->AsKeyboardEvent(), aCodeName);
 111 }
 112
 113 void KeyboardEvent::GetInitDict(KeyboardEventInit& aParam) {
 114   GetKey(aParam.mKey);
 115   GetCode(aParam.mCode);
 116   aParam.mLocation = Location();
 117   aParam.mRepeat = Repeat();
 118   aParam.mIsComposing = IsComposing();
 119
 120   // legacy attributes
 121   aParam.mKeyCode = KeyCode();
 122   aParam.mCharCode = CharCode();
 123   aParam.mWhich = Which();
 124
 125   // modifiers from EventModifierInit
 126   aParam.mCtrlKey = CtrlKey();
 127   aParam.mShiftKey = ShiftKey();
 128   aParam.mAltKey = AltKey();
 129   aParam.mMetaKey = MetaKey();
 130
 131   WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
 132   aParam.mModifierAltGraph = internalEvent->IsAltGraph();
 133   aParam.mModifierCapsLock = internalEvent->IsCapsLocked();
 134   aParam.mModifierFn = internalEvent->IsFn();
 135   aParam.mModifierFnLock = internalEvent->IsFnLocked();
 136   aParam.mModifierNumLock = internalEvent->IsNumLocked();
 137   aParam.mModifierScrollLock = internalEvent->IsScrollLocked();
 138   aParam.mModifierSymbol = internalEvent->IsSymbol();
 139   aParam.mModifierSymbolLock = internalEvent->IsSymbolLocked();
 140
 141   // EventInit
 142   aParam.mBubbles = internalEvent->mFlags.mBubbles;
 143   aParam.mCancelable = internalEvent->mFlags.mCancelable;
 144 }
 145
 146 bool KeyboardEvent::ShouldUseSameValueForCharCodeAndKeyCode(
 147     const WidgetKeyboardEvent& aWidgetKeyboardEvent,
 148     CallerType aCallerType) const {
 149   // - If this event is initialized by JS, we don't need to return same value
 150   //   for keyCode and charCode since they can be initialized separately.
 151   // - If this is not a keypress event, we shouldn't return same value for
 152   //   keyCode and charCode.
 153   // - If we need to return legacy keyCode and charCode values for the web
 154   //   app due to in the blacklist.
 155   // - If this event is referred by default handler, i.e., the caller is
 156   //   system or this event is now in the system group, we don't need to use
 157   //   hack for web-compat.
 158   if (mInitializedByJS || aWidgetKeyboardEvent.mMessage != eKeyPress ||
 159       aWidgetKeyboardEvent.mUseLegacyKeyCodeAndCharCodeValues ||
 160       aCallerType == CallerType::System ||
 161       aWidgetKeyboardEvent.mFlags.mInSystemGroup) {
 162     return false;
 163   }
 164
 165   MOZ_ASSERT(aCallerType == CallerType::NonSystem);
 166
 167   return StaticPrefs::
 168       dom_keyboardevent_keypress_set_keycode_and_charcode_to_same_value();
 169 }
 170
 171 uint32_t KeyboardEvent::CharCode(CallerType aCallerType) {
 172   WidgetKeyboardEvent* widgetKeyboardEvent = mEvent->AsKeyboardEvent();
 173   if (mInitializedByJS) {
 174     // If this is initialized by Ctor, we should return the initialized value.
 175     if (mInitializedByCtor) {
 176       return widgetKeyboardEvent->mCharCode;
 177     }
 178     // Otherwise, i.e., initialized by InitKey*Event(), we should return the
 179     // initialized value only when eKeyPress or eAccessKeyNotFound event.
 180     // Although this is odd, but our traditional behavior.
 181     return widgetKeyboardEvent->mMessage == eKeyPress ||
 182                    widgetKeyboardEvent->mMessage == eAccessKeyNotFound
 183                ? widgetKeyboardEvent->mCharCode
 184                : 0;
 185   }
 186
 187   // If the key is a function key, we should return the result of KeyCode()
 188   // even from CharCode().  Otherwise, i.e., the key may be a printable
 189   // key or actually a printable key, we should return the given charCode
 190   // value.
 191
 192   if (widgetKeyboardEvent->mKeyNameIndex != KEY_NAME_INDEX_USE_STRING &&
 193       ShouldUseSameValueForCharCodeAndKeyCode(*widgetKeyboardEvent,
 194                                               aCallerType)) {
 195     return ComputeTraditionalKeyCode(*widgetKeyboardEvent, aCallerType);
 196   }
 197
 198   return widgetKeyboardEvent->mCharCode;
 199 }
 200
 201 uint32_t KeyboardEvent::KeyCode(CallerType aCallerType) {
 202   WidgetKeyboardEvent* widgetKeyboardEvent = mEvent->AsKeyboardEvent();
 203   if (mInitializedByJS) {
 204     // If this is initialized by Ctor, we should return the initialized value.
 205     if (mInitializedByCtor) {
 206       return widgetKeyboardEvent->mKeyCode;
 207     }
 208     // Otherwise, i.e., initialized by InitKey*Event(), we should return the
 209     // initialized value only when the event message is a valid keyboard event
 210     // message.  Although this is odd, but our traditional behavior.
 211     // NOTE: The fix of bug 1222285 changed the behavior temporarily if
 212     //       spoofing is enabled.  However, the behavior does not make sense
 213     //       since if the event is generated by JS, the behavior shouldn't
 214     //       be changed by whether spoofing is enabled or not.  Therefore,
 215     //       we take back the original behavior.
 216     return widgetKeyboardEvent->HasKeyEventMessage()
 217                ? widgetKeyboardEvent->mKeyCode
 218                : 0;
 219   }
 220
 221   // If the key is not a function key, i.e., the key may be a printable key
 222   // or a function key mapped as a printable key, we should use charCode value
 223   // for keyCode value if this is a "keypress" event.
 224
 225   if (widgetKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_USE_STRING &&
 226       ShouldUseSameValueForCharCodeAndKeyCode(*widgetKeyboardEvent,
 227                                               aCallerType)) {
 228     return widgetKeyboardEvent->mCharCode;
 229   }
 230
 231   return ComputeTraditionalKeyCode(*widgetKeyboardEvent, aCallerType);
 232 }
 233
 234 uint32_t KeyboardEvent::ComputeTraditionalKeyCode(
 235     WidgetKeyboardEvent& aKeyboardEvent, CallerType aCallerType) {
 236   if (!ShouldResistFingerprinting(aCallerType)) {
 237     return aKeyboardEvent.mKeyCode;
 238   }
 239
 240   // In Netscape style (i.e., traditional behavior of Gecko), the keyCode
 241   // should be zero if the char code is given.
 242   if ((mEvent->mMessage == eKeyPress ||
 243        mEvent->mMessage == eAccessKeyNotFound) &&
 244       aKeyboardEvent.mCharCode) {
 245     return 0;
 246   }
 247
 248   // When fingerprinting resistance is enabled, we will give a spoofed keyCode
 249   // according to the content-language of the document.
 250   nsCOMPtr<Document> doc = GetDocument();
 251   uint32_t spoofedKeyCode;
 252
 253   if (nsRFPService::GetSpoofedKeyCode(doc, &aKeyboardEvent, spoofedKeyCode)) {
 254     return spoofedKeyCode;
 255   }
 256
 257   return 0;
 258 }
 259
 260 uint32_t KeyboardEvent::Which(CallerType aCallerType) {
 261   // If this event is initialized with ctor, which can have independent value.
 262   if (mInitializedByCtor) {
 263     return mInitializedWhichValue;
 264   }
 265
 266   switch (mEvent->mMessage) {
 267     case eKeyDown:
 268     case eKeyUp:
 269       return KeyCode(aCallerType);
 270     case eKeyPress:
 271       // Special case for 4xp bug 62878.  Try to make value of which
 272       // more closely mirror the values that 4.x gave for RETURN and BACKSPACE
 273       {
 274         uint32_t keyCode = mEvent->AsKeyboardEvent()->mKeyCode;
 275         if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
 276           return keyCode;
 277         }
 278         return CharCode();
 279       }
 280     default:
 281       break;
 282   }
 283
 284   return 0;
 285 }
 286
 287 uint32_t KeyboardEvent::Location() {
 288   return mEvent->AsKeyboardEvent()->mLocation;
 289 }
 290
 291 // static
 292 already_AddRefed<KeyboardEvent> KeyboardEvent::ConstructorJS(
 293     const GlobalObject& aGlobal, const nsAString& aType,
 294     const KeyboardEventInit& aParam) {
 295   nsCOMPtr<EventTarget> target = do_QueryInterface(aGlobal.GetAsSupports());
 296   RefPtr<KeyboardEvent> newEvent = new KeyboardEvent(target, nullptr, nullptr);
 297   newEvent->InitWithKeyboardEventInit(target, aType, aParam);
 298
 299   return newEvent.forget();
 300 }
 301
 302 void KeyboardEvent::InitWithKeyboardEventInit(EventTarget* aOwner,
 303                                               const nsAString& aType,
 304                                               const KeyboardEventInit& aParam) {
 305   bool trusted = Init(aOwner);
 306   InitKeyEventJS(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
 307                  false, false, false, false, aParam.mKeyCode, aParam.mCharCode);
 308   InitModifiers(aParam);
 309   SetTrusted(trusted);
 310   mDetail = aParam.mDetail;
 311   mInitializedByJS = true;
 312   mInitializedByCtor = true;
 313   mInitializedWhichValue = aParam.mWhich;
 314
 315   WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
 316   internalEvent->mLocation = aParam.mLocation;
 317   internalEvent->mIsRepeat = aParam.mRepeat;
 318   internalEvent->mIsComposing = aParam.mIsComposing;
 319   internalEvent->mKeyNameIndex =
 320       WidgetKeyboardEvent::GetKeyNameIndex(aParam.mKey);
 321   if (internalEvent->mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {
 322     internalEvent->mKeyValue = aParam.mKey;
 323   }
 324   internalEvent->mCodeNameIndex =
 325       WidgetKeyboardEvent::GetCodeNameIndex(aParam.mCode);
 326   if (internalEvent->mCodeNameIndex == CODE_NAME_INDEX_USE_STRING) {
 327     internalEvent->mCodeValue = aParam.mCode;
 328   }
 329 }
 330
 331 // static
 332 bool KeyboardEvent::IsInitKeyEventAvailable(JSContext* aCx, JSObject*) {
 333   if (StaticPrefs::dom_keyboardevent_init_key_event_enabled()) {
 334     return true;
 335   }
 336   if (!StaticPrefs::dom_keyboardevent_init_key_event_enabled_in_addons()) {
 337     return false;
 338   }
 339   nsIPrincipal* principal = nsContentUtils::SubjectPrincipal(aCx);
 340   return principal && principal->GetIsAddonOrExpandedAddonPrincipal();
 341 }
 342
 343 void KeyboardEvent::InitKeyEventJS(const nsAString& aType, bool aCanBubble,
 344                                    bool aCancelable, nsGlobalWindowInner* aView,
 345                                    bool aCtrlKey, bool aAltKey, bool aShiftKey,
 346                                    bool aMetaKey, uint32_t aKeyCode,
 347                                    uint32_t aCharCode) {
 348   NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
 349   mInitializedByJS = true;
 350   mInitializedByCtor = false;
 351
 352   UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, 0);
 353
 354   WidgetKeyboardEvent* keyEvent = mEvent->AsKeyboardEvent();
 355   keyEvent->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
 356   keyEvent->mKeyCode = aKeyCode;
 357   keyEvent->mCharCode = aCharCode;
 358 }
 359
 360 void KeyboardEvent::InitKeyboardEventJS(
 361     const nsAString& aType, bool aCanBubble, bool aCancelable,
 362     nsGlobalWindowInner* aView, const nsAString& aKey, uint32_t aLocation,
 363     bool aCtrlKey, bool aAltKey, bool aShiftKey, bool aMetaKey) {
 364   NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
 365   mInitializedByJS = true;
 366   mInitializedByCtor = false;
 367
 368   UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, 0);
 369
 370   WidgetKeyboardEvent* keyEvent = mEvent->AsKeyboardEvent();
 371   keyEvent->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
 372   keyEvent->mLocation = aLocation;
 373   keyEvent->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
 374   keyEvent->mKeyValue = aKey;
 375 }
 376
 377 bool KeyboardEvent::ShouldResistFingerprinting(CallerType aCallerType) {
 378   // There are five situations we don't need to spoof this keyboard event.
 379   //   1. The pref privcy.resistFingerprinting' is false, we fast return here.
 380   //   2. This event is initialized by scripts.
 381   //   3. This event is from Numpad.
 382   //   4. This event is in the system group.
 383   //   5. The caller type is system.
 384   if (!nsContentUtils::ShouldResistFingerprinting("Efficiency Check",
 385                                                   RFPTarget::KeyboardEvents) ||
 386       mInitializedByJS || aCallerType == CallerType::System ||
 387       mEvent->mFlags.mInSystemGroup ||
 388       mEvent->AsKeyboardEvent()->mLocation ==
 389           KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD) {
 390     return false;
 391   }
 392
 393   nsCOMPtr<Document> doc = GetDocument();
 394   // We've checked the pref above, so use true as fallback if doc is null.
 395   return doc ? doc->ShouldResistFingerprinting(RFPTarget::KeyboardEvents)
 396              : true;
 397 }
 398
 399 bool KeyboardEvent::GetSpoofedModifierStates(const Modifiers aModifierKey,
 400                                              const bool aRawModifierState) {
 401   bool spoofedState;
 402   nsCOMPtr<Document> doc = GetDocument();
 403
 404   if (nsRFPService::GetSpoofedModifierStates(doc, mEvent->AsKeyboardEvent(),
 405                                              aModifierKey, spoofedState)) {
 406     return spoofedState;
 407   }
 408
 409   return aRawModifierState;
 410 }
 411
 412 }  // namespace mozilla::dom
 413
 414 using namespace mozilla;
 415 using namespace mozilla::dom;
 416
 417 already_AddRefed<KeyboardEvent> NS_NewDOMKeyboardEvent(
 418     EventTarget* aOwner, nsPresContext* aPresContext,
 419     WidgetKeyboardEvent* aEvent) {
 420   RefPtr<KeyboardEvent> it = new KeyboardEvent(aOwner, aPresContext, aEvent);
 421   return it.forget();
 422 }