Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#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.
// 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:
// 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();
}