forked from mirrors/gecko-dev
0f39d7eda7
On Windows, Windows logo key was mapped to "OS" modifier, and on Linux, it's same and the key is called "Super" and "Hyper". That conformed to the older UI Events spec. However, UI Events declares that they should be mapped to "Meta" now and Chrome handles it as the spec in Windows and Linux. Therefore, we should align the behavior to them. Note that we've treated the legacy "Meta" modifier on Linux as DOM "Meta" modifier state, and we'll keep this as-is because in Sun/Solaris keyboard layout, they keys are mapped to the legacy "Meta". Finally, the following check only `IsMeta()` but not `IsOS()`. I think that they should've checked `IsOS()` too. Therefore, they will behave differently in Windows and Linux. * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/base/Element.cpp#3287-3288 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLInputElement.cpp#3762-3764 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLInputElement.cpp#3796-3806 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLLabelElement.cpp#127-128 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/widget/gtk/nsGtkKeyUtils.cpp#1461-1462 Note that `KEY_NAME_INDEX_OS` will be removed in the patch for bug 1232918. Differential Revision: https://phabricator.services.mozilla.com/D183480
422 lines
15 KiB
C++
422 lines
15 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
|
|
#include "mozilla/dom/KeyboardEvent.h"
|
|
|
|
#include "mozilla/BasicEvents.h"
|
|
#include "mozilla/StaticPrefs_dom.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/LookAndFeel.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsRFPService.h"
|
|
#include "prtime.h"
|
|
|
|
namespace mozilla::dom {
|
|
|
|
KeyboardEvent::KeyboardEvent(EventTarget* aOwner, nsPresContext* aPresContext,
|
|
WidgetKeyboardEvent* aEvent)
|
|
: UIEvent(aOwner, aPresContext,
|
|
aEvent ? aEvent
|
|
: new WidgetKeyboardEvent(false, eVoidEvent, nullptr)),
|
|
mInitializedByJS(false),
|
|
mInitializedByCtor(false),
|
|
mInitializedWhichValue(0) {
|
|
if (aEvent) {
|
|
mEventIsInternal = false;
|
|
} else {
|
|
mEventIsInternal = true;
|
|
mEvent->AsKeyboardEvent()->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
|
|
}
|
|
}
|
|
|
|
bool KeyboardEvent::IsMenuAccessKeyPressed() const {
|
|
Modifiers mask = LookAndFeel::GetMenuAccessKeyModifiers();
|
|
Modifiers modifiers = GetModifiersForMenuAccessKey();
|
|
return mask != MODIFIER_SHIFT && (modifiers & mask) &&
|
|
(modifiers & ~(mask | MODIFIER_SHIFT)) == 0;
|
|
}
|
|
|
|
static constexpr Modifiers kPossibleModifiersForAccessKey =
|
|
MODIFIER_SHIFT | MODIFIER_CONTROL | MODIFIER_ALT | MODIFIER_META;
|
|
|
|
Modifiers KeyboardEvent::GetModifiersForMenuAccessKey() const {
|
|
const WidgetInputEvent* inputEvent = WidgetEventPtr()->AsInputEvent();
|
|
MOZ_ASSERT(inputEvent);
|
|
return inputEvent->mModifiers & kPossibleModifiersForAccessKey;
|
|
}
|
|
|
|
bool KeyboardEvent::AltKey(CallerType aCallerType) {
|
|
bool altState = mEvent->AsKeyboardEvent()->IsAlt();
|
|
|
|
if (!ShouldResistFingerprinting(aCallerType)) {
|
|
return altState;
|
|
}
|
|
|
|
// We need to give a spoofed state for Alt key since it could be used as a
|
|
// modifier key in certain keyboard layout. For example, the '@' key for
|
|
// German keyboard for MAC is Alt+L.
|
|
return GetSpoofedModifierStates(Modifier::MODIFIER_ALT, altState);
|
|
}
|
|
|
|
bool KeyboardEvent::CtrlKey(CallerType aCallerType) {
|
|
// We don't spoof this key when privacy.resistFingerprinting
|
|
// is enabled, because it is often used for command key
|
|
// combinations in web apps.
|
|
return mEvent->AsKeyboardEvent()->IsControl();
|
|
}
|
|
|
|
bool KeyboardEvent::ShiftKey(CallerType aCallerType) {
|
|
bool shiftState = mEvent->AsKeyboardEvent()->IsShift();
|
|
|
|
if (!ShouldResistFingerprinting(aCallerType)) {
|
|
return shiftState;
|
|
}
|
|
|
|
return GetSpoofedModifierStates(Modifier::MODIFIER_SHIFT, shiftState);
|
|
}
|
|
|
|
bool KeyboardEvent::MetaKey() {
|
|
// We don't spoof this key when privacy.resistFingerprinting
|
|
// is enabled, because it is often used for command key
|
|
// combinations in web apps.
|
|
return mEvent->AsKeyboardEvent()->IsMeta();
|
|
}
|
|
|
|
bool KeyboardEvent::Repeat() { return mEvent->AsKeyboardEvent()->mIsRepeat; }
|
|
|
|
bool KeyboardEvent::IsComposing() {
|
|
return mEvent->AsKeyboardEvent()->mIsComposing;
|
|
}
|
|
|
|
void KeyboardEvent::GetKey(nsAString& aKeyName) const {
|
|
mEvent->AsKeyboardEvent()->GetDOMKeyName(aKeyName);
|
|
}
|
|
|
|
void KeyboardEvent::GetCode(nsAString& aCodeName, CallerType aCallerType) {
|
|
if (!ShouldResistFingerprinting(aCallerType)) {
|
|
mEvent->AsKeyboardEvent()->GetDOMCodeName(aCodeName);
|
|
return;
|
|
}
|
|
|
|
// When fingerprinting resistance is enabled, we will give a spoofed code
|
|
// according to the content-language of the document.
|
|
nsCOMPtr<Document> doc = GetDocument();
|
|
|
|
nsRFPService::GetSpoofedCode(doc, mEvent->AsKeyboardEvent(), aCodeName);
|
|
}
|
|
|
|
void KeyboardEvent::GetInitDict(KeyboardEventInit& aParam) {
|
|
GetKey(aParam.mKey);
|
|
GetCode(aParam.mCode);
|
|
aParam.mLocation = Location();
|
|
aParam.mRepeat = Repeat();
|
|
aParam.mIsComposing = IsComposing();
|
|
|
|
// legacy attributes
|
|
aParam.mKeyCode = KeyCode();
|
|
aParam.mCharCode = CharCode();
|
|
aParam.mWhich = Which();
|
|
|
|
// modifiers from EventModifierInit
|
|
aParam.mCtrlKey = CtrlKey();
|
|
aParam.mShiftKey = ShiftKey();
|
|
aParam.mAltKey = AltKey();
|
|
aParam.mMetaKey = MetaKey();
|
|
|
|
WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
|
|
aParam.mModifierAltGraph = internalEvent->IsAltGraph();
|
|
aParam.mModifierCapsLock = internalEvent->IsCapsLocked();
|
|
aParam.mModifierFn = internalEvent->IsFn();
|
|
aParam.mModifierFnLock = internalEvent->IsFnLocked();
|
|
aParam.mModifierNumLock = internalEvent->IsNumLocked();
|
|
aParam.mModifierScrollLock = internalEvent->IsScrollLocked();
|
|
aParam.mModifierSymbol = internalEvent->IsSymbol();
|
|
aParam.mModifierSymbolLock = internalEvent->IsSymbolLocked();
|
|
|
|
// EventInit
|
|
aParam.mBubbles = internalEvent->mFlags.mBubbles;
|
|
aParam.mCancelable = internalEvent->mFlags.mCancelable;
|
|
}
|
|
|
|
bool KeyboardEvent::ShouldUseSameValueForCharCodeAndKeyCode(
|
|
const WidgetKeyboardEvent& aWidgetKeyboardEvent,
|
|
CallerType aCallerType) const {
|
|
// - If this event is initialized by JS, we don't need to return same value
|
|
// for keyCode and charCode since they can be initialized separately.
|
|
// - If this is not a keypress event, we shouldn't return same value for
|
|
// keyCode and charCode.
|
|
// - If we need to return legacy keyCode and charCode values for the web
|
|
// app due to in the blacklist.
|
|
// - If this event is referred by default handler, i.e., the caller is
|
|
// system or this event is now in the system group, we don't need to use
|
|
// hack for web-compat.
|
|
if (mInitializedByJS || aWidgetKeyboardEvent.mMessage != eKeyPress ||
|
|
aWidgetKeyboardEvent.mUseLegacyKeyCodeAndCharCodeValues ||
|
|
aCallerType == CallerType::System ||
|
|
aWidgetKeyboardEvent.mFlags.mInSystemGroup) {
|
|
return false;
|
|
}
|
|
|
|
MOZ_ASSERT(aCallerType == CallerType::NonSystem);
|
|
|
|
return StaticPrefs::
|
|
dom_keyboardevent_keypress_set_keycode_and_charcode_to_same_value();
|
|
}
|
|
|
|
uint32_t KeyboardEvent::CharCode(CallerType aCallerType) {
|
|
WidgetKeyboardEvent* widgetKeyboardEvent = mEvent->AsKeyboardEvent();
|
|
if (mInitializedByJS) {
|
|
// If this is initialized by Ctor, we should return the initialized value.
|
|
if (mInitializedByCtor) {
|
|
return widgetKeyboardEvent->mCharCode;
|
|
}
|
|
// Otherwise, i.e., initialized by InitKey*Event(), we should return the
|
|
// initialized value only when eKeyPress or eAccessKeyNotFound event.
|
|
// Although this is odd, but our traditional behavior.
|
|
return widgetKeyboardEvent->mMessage == eKeyPress ||
|
|
widgetKeyboardEvent->mMessage == eAccessKeyNotFound
|
|
? widgetKeyboardEvent->mCharCode
|
|
: 0;
|
|
}
|
|
|
|
// If the key is a function key, we should return the result of KeyCode()
|
|
// even from CharCode(). Otherwise, i.e., the key may be a printable
|
|
// key or actually a printable key, we should return the given charCode
|
|
// value.
|
|
|
|
if (widgetKeyboardEvent->mKeyNameIndex != KEY_NAME_INDEX_USE_STRING &&
|
|
ShouldUseSameValueForCharCodeAndKeyCode(*widgetKeyboardEvent,
|
|
aCallerType)) {
|
|
return ComputeTraditionalKeyCode(*widgetKeyboardEvent, aCallerType);
|
|
}
|
|
|
|
return widgetKeyboardEvent->mCharCode;
|
|
}
|
|
|
|
uint32_t KeyboardEvent::KeyCode(CallerType aCallerType) {
|
|
WidgetKeyboardEvent* widgetKeyboardEvent = mEvent->AsKeyboardEvent();
|
|
if (mInitializedByJS) {
|
|
// If this is initialized by Ctor, we should return the initialized value.
|
|
if (mInitializedByCtor) {
|
|
return widgetKeyboardEvent->mKeyCode;
|
|
}
|
|
// Otherwise, i.e., initialized by InitKey*Event(), we should return the
|
|
// initialized value only when the event message is a valid keyboard event
|
|
// message. Although this is odd, but our traditional behavior.
|
|
// NOTE: The fix of bug 1222285 changed the behavior temporarily if
|
|
// spoofing is enabled. However, the behavior does not make sense
|
|
// since if the event is generated by JS, the behavior shouldn't
|
|
// be changed by whether spoofing is enabled or not. Therefore,
|
|
// we take back the original behavior.
|
|
return widgetKeyboardEvent->HasKeyEventMessage()
|
|
? widgetKeyboardEvent->mKeyCode
|
|
: 0;
|
|
}
|
|
|
|
// If the key is not a function key, i.e., the key may be a printable key
|
|
// or a function key mapped as a printable key, we should use charCode value
|
|
// for keyCode value if this is a "keypress" event.
|
|
|
|
if (widgetKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_USE_STRING &&
|
|
ShouldUseSameValueForCharCodeAndKeyCode(*widgetKeyboardEvent,
|
|
aCallerType)) {
|
|
return widgetKeyboardEvent->mCharCode;
|
|
}
|
|
|
|
return ComputeTraditionalKeyCode(*widgetKeyboardEvent, aCallerType);
|
|
}
|
|
|
|
uint32_t KeyboardEvent::ComputeTraditionalKeyCode(
|
|
WidgetKeyboardEvent& aKeyboardEvent, CallerType aCallerType) {
|
|
if (!ShouldResistFingerprinting(aCallerType)) {
|
|
return aKeyboardEvent.mKeyCode;
|
|
}
|
|
|
|
// In Netscape style (i.e., traditional behavior of Gecko), the keyCode
|
|
// should be zero if the char code is given.
|
|
if ((mEvent->mMessage == eKeyPress ||
|
|
mEvent->mMessage == eAccessKeyNotFound) &&
|
|
aKeyboardEvent.mCharCode) {
|
|
return 0;
|
|
}
|
|
|
|
// When fingerprinting resistance is enabled, we will give a spoofed keyCode
|
|
// according to the content-language of the document.
|
|
nsCOMPtr<Document> doc = GetDocument();
|
|
uint32_t spoofedKeyCode;
|
|
|
|
if (nsRFPService::GetSpoofedKeyCode(doc, &aKeyboardEvent, spoofedKeyCode)) {
|
|
return spoofedKeyCode;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t KeyboardEvent::Which(CallerType aCallerType) {
|
|
// If this event is initialized with ctor, which can have independent value.
|
|
if (mInitializedByCtor) {
|
|
return mInitializedWhichValue;
|
|
}
|
|
|
|
switch (mEvent->mMessage) {
|
|
case eKeyDown:
|
|
case eKeyUp:
|
|
return KeyCode(aCallerType);
|
|
case eKeyPress:
|
|
// Special case for 4xp bug 62878. Try to make value of which
|
|
// more closely mirror the values that 4.x gave for RETURN and BACKSPACE
|
|
{
|
|
uint32_t keyCode = mEvent->AsKeyboardEvent()->mKeyCode;
|
|
if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
|
|
return keyCode;
|
|
}
|
|
return CharCode();
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t KeyboardEvent::Location() {
|
|
return mEvent->AsKeyboardEvent()->mLocation;
|
|
}
|
|
|
|
// static
|
|
already_AddRefed<KeyboardEvent> KeyboardEvent::ConstructorJS(
|
|
const GlobalObject& aGlobal, const nsAString& aType,
|
|
const KeyboardEventInit& aParam) {
|
|
nsCOMPtr<EventTarget> target = do_QueryInterface(aGlobal.GetAsSupports());
|
|
RefPtr<KeyboardEvent> newEvent = new KeyboardEvent(target, nullptr, nullptr);
|
|
newEvent->InitWithKeyboardEventInit(target, aType, aParam);
|
|
|
|
return newEvent.forget();
|
|
}
|
|
|
|
void KeyboardEvent::InitWithKeyboardEventInit(EventTarget* aOwner,
|
|
const nsAString& aType,
|
|
const KeyboardEventInit& aParam) {
|
|
bool trusted = Init(aOwner);
|
|
InitKeyEventJS(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
|
|
false, false, false, false, aParam.mKeyCode, aParam.mCharCode);
|
|
InitModifiers(aParam);
|
|
SetTrusted(trusted);
|
|
mDetail = aParam.mDetail;
|
|
mInitializedByJS = true;
|
|
mInitializedByCtor = true;
|
|
mInitializedWhichValue = aParam.mWhich;
|
|
|
|
WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
|
|
internalEvent->mLocation = aParam.mLocation;
|
|
internalEvent->mIsRepeat = aParam.mRepeat;
|
|
internalEvent->mIsComposing = aParam.mIsComposing;
|
|
internalEvent->mKeyNameIndex =
|
|
WidgetKeyboardEvent::GetKeyNameIndex(aParam.mKey);
|
|
if (internalEvent->mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {
|
|
internalEvent->mKeyValue = aParam.mKey;
|
|
}
|
|
internalEvent->mCodeNameIndex =
|
|
WidgetKeyboardEvent::GetCodeNameIndex(aParam.mCode);
|
|
if (internalEvent->mCodeNameIndex == CODE_NAME_INDEX_USE_STRING) {
|
|
internalEvent->mCodeValue = aParam.mCode;
|
|
}
|
|
}
|
|
|
|
// static
|
|
bool KeyboardEvent::IsInitKeyEventAvailable(JSContext* aCx, JSObject*) {
|
|
if (StaticPrefs::dom_keyboardevent_init_key_event_enabled()) {
|
|
return true;
|
|
}
|
|
if (!StaticPrefs::dom_keyboardevent_init_key_event_enabled_in_addons()) {
|
|
return false;
|
|
}
|
|
nsIPrincipal* principal = nsContentUtils::SubjectPrincipal(aCx);
|
|
return principal && principal->GetIsAddonOrExpandedAddonPrincipal();
|
|
}
|
|
|
|
void KeyboardEvent::InitKeyEventJS(const nsAString& aType, bool aCanBubble,
|
|
bool aCancelable, nsGlobalWindowInner* aView,
|
|
bool aCtrlKey, bool aAltKey, bool aShiftKey,
|
|
bool aMetaKey, uint32_t aKeyCode,
|
|
uint32_t aCharCode) {
|
|
NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
|
|
mInitializedByJS = true;
|
|
mInitializedByCtor = false;
|
|
|
|
UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, 0);
|
|
|
|
WidgetKeyboardEvent* keyEvent = mEvent->AsKeyboardEvent();
|
|
keyEvent->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
|
|
keyEvent->mKeyCode = aKeyCode;
|
|
keyEvent->mCharCode = aCharCode;
|
|
}
|
|
|
|
void KeyboardEvent::InitKeyboardEventJS(
|
|
const nsAString& aType, bool aCanBubble, bool aCancelable,
|
|
nsGlobalWindowInner* aView, const nsAString& aKey, uint32_t aLocation,
|
|
bool aCtrlKey, bool aAltKey, bool aShiftKey, bool aMetaKey) {
|
|
NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
|
|
mInitializedByJS = true;
|
|
mInitializedByCtor = false;
|
|
|
|
UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, 0);
|
|
|
|
WidgetKeyboardEvent* keyEvent = mEvent->AsKeyboardEvent();
|
|
keyEvent->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
|
|
keyEvent->mLocation = aLocation;
|
|
keyEvent->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
|
|
keyEvent->mKeyValue = aKey;
|
|
}
|
|
|
|
bool KeyboardEvent::ShouldResistFingerprinting(CallerType aCallerType) {
|
|
// There are five situations we don't need to spoof this keyboard event.
|
|
// 1. The pref privcy.resistFingerprinting' is false, we fast return here.
|
|
// 2. This event is initialized by scripts.
|
|
// 3. This event is from Numpad.
|
|
// 4. This event is in the system group.
|
|
// 5. The caller type is system.
|
|
if (!nsContentUtils::ShouldResistFingerprinting("Efficiency Check",
|
|
RFPTarget::KeyboardEvents) ||
|
|
mInitializedByJS || aCallerType == CallerType::System ||
|
|
mEvent->mFlags.mInSystemGroup ||
|
|
mEvent->AsKeyboardEvent()->mLocation ==
|
|
KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<Document> doc = GetDocument();
|
|
// We've checked the pref above, so use true as fallback if doc is null.
|
|
return doc ? doc->ShouldResistFingerprinting(RFPTarget::KeyboardEvents)
|
|
: true;
|
|
}
|
|
|
|
bool KeyboardEvent::GetSpoofedModifierStates(const Modifiers aModifierKey,
|
|
const bool aRawModifierState) {
|
|
bool spoofedState;
|
|
nsCOMPtr<Document> doc = GetDocument();
|
|
|
|
if (nsRFPService::GetSpoofedModifierStates(doc, mEvent->AsKeyboardEvent(),
|
|
aModifierKey, spoofedState)) {
|
|
return spoofedState;
|
|
}
|
|
|
|
return aRawModifierState;
|
|
}
|
|
|
|
} // namespace mozilla::dom
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
already_AddRefed<KeyboardEvent> NS_NewDOMKeyboardEvent(
|
|
EventTarget* aOwner, nsPresContext* aPresContext,
|
|
WidgetKeyboardEvent* aEvent) {
|
|
RefPtr<KeyboardEvent> it = new KeyboardEvent(aOwner, aPresContext, aEvent);
|
|
return it.forget();
|
|
}
|