diff options
Diffstat (limited to 'widget/TextEventDispatcher.cpp')
| -rw-r--r-- | widget/TextEventDispatcher.cpp | 1043 |
1 files changed, 1043 insertions, 0 deletions
diff --git a/widget/TextEventDispatcher.cpp b/widget/TextEventDispatcher.cpp new file mode 100644 index 0000000000..cf414a23e3 --- /dev/null +++ b/widget/TextEventDispatcher.cpp @@ -0,0 +1,1043 @@ +/* -*- Mode: C++; tab-width: 2; 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/. */ + +#include "TextEventDispatcher.h" + +#include "IMEData.h" +#include "PuppetWidget.h" +#include "TextEvents.h" + +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_dom.h" +#include "nsCharTraits.h" +#include "nsIFrame.h" +#include "nsIWidget.h" +#include "nsPIDOMWindow.h" +#include "nsView.h" + +namespace mozilla { +namespace widget { + +/****************************************************************************** + * TextEventDispatcher + *****************************************************************************/ +TextEventDispatcher::TextEventDispatcher(nsIWidget* aWidget) + : mWidget(aWidget), + mDispatchingEvent(0), + mInputTransactionType(eNoInputTransaction), + mIsComposing(false), + mIsHandlingComposition(false), + mHasFocus(false) { + MOZ_RELEASE_ASSERT(mWidget, "aWidget must not be nullptr"); + + ClearNotificationRequests(); +} + +nsresult TextEventDispatcher::BeginInputTransaction( + TextEventDispatcherListener* aListener) { + return BeginInputTransactionInternal(aListener, + eSameProcessSyncInputTransaction); +} + +nsresult TextEventDispatcher::BeginTestInputTransaction( + TextEventDispatcherListener* aListener, bool aIsAPZAware) { + return BeginInputTransactionInternal( + aListener, aIsAPZAware ? eAsyncTestInputTransaction + : eSameProcessSyncTestInputTransaction); +} + +nsresult TextEventDispatcher::BeginNativeInputTransaction() { + if (NS_WARN_IF(!mWidget)) { + return NS_ERROR_FAILURE; + } + RefPtr<TextEventDispatcherListener> listener = + mWidget->GetNativeTextEventDispatcherListener(); + if (NS_WARN_IF(!listener)) { + return NS_ERROR_FAILURE; + } + return BeginInputTransactionInternal(listener, eNativeInputTransaction); +} + +nsresult TextEventDispatcher::BeginInputTransactionInternal( + TextEventDispatcherListener* aListener, InputTransactionType aType) { + if (NS_WARN_IF(!aListener)) { + return NS_ERROR_INVALID_ARG; + } + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + if (listener) { + if (listener == aListener && mInputTransactionType == aType) { + UpdateNotificationRequests(); + return NS_OK; + } + // If this has composition or is dispatching an event, any other listener + // can steal ownership. Especially, if the latter case is allowed, + // nobody cannot begin input transaction with this if a modal dialog is + // opened during dispatching an event. + if (IsComposing() || IsDispatchingEvent()) { + return NS_ERROR_ALREADY_INITIALIZED; + } + } + mListener = do_GetWeakReference(aListener); + mInputTransactionType = aType; + if (listener && listener != aListener) { + listener->OnRemovedFrom(this); + } + UpdateNotificationRequests(); + return NS_OK; +} + +nsresult TextEventDispatcher::BeginInputTransactionFor( + const WidgetGUIEvent* aEvent, PuppetWidget* aPuppetWidget) { + MOZ_ASSERT(XRE_IsContentProcess()); + MOZ_ASSERT(!IsDispatchingEvent()); + + switch (aEvent->mMessage) { + case eKeyDown: + case eKeyPress: + case eKeyUp: + MOZ_ASSERT(aEvent->mClass == eKeyboardEventClass); + break; + case eCompositionStart: + case eCompositionChange: + case eCompositionCommit: + case eCompositionCommitAsIs: + MOZ_ASSERT(aEvent->mClass == eCompositionEventClass); + break; + default: + return NS_ERROR_INVALID_ARG; + } + + if (aEvent->mFlags.mIsSynthesizedForTests) { + // If the event is for an automated test and this instance dispatched + // an event to the parent process, we can assume that this is already + // initialized properly. + if (mInputTransactionType == eAsyncTestInputTransaction) { + return NS_OK; + } + // Even if the event coming from the parent process is synthesized for + // tests, this process should treat it as "sync" test here because + // it won't be go back to the parent process. + nsresult rv = BeginInputTransactionInternal( + static_cast<TextEventDispatcherListener*>(aPuppetWidget), + eSameProcessSyncTestInputTransaction); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } else { + nsresult rv = BeginNativeInputTransaction(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + // Emulate modifying members which indicate the state of composition. + // If we need to manage more states and/or more complexly, we should create + // internal methods which are called by both here and each event dispatcher + // method of this class. + switch (aEvent->mMessage) { + case eKeyDown: + case eKeyPress: + case eKeyUp: + return NS_OK; + case eCompositionStart: + MOZ_ASSERT(!mIsComposing); + mIsComposing = mIsHandlingComposition = true; + return NS_OK; + case eCompositionChange: + MOZ_ASSERT(mIsComposing); + MOZ_ASSERT(mIsHandlingComposition); + mIsComposing = mIsHandlingComposition = true; + return NS_OK; + case eCompositionCommit: + case eCompositionCommitAsIs: + MOZ_ASSERT(mIsComposing); + MOZ_ASSERT(mIsHandlingComposition); + mIsComposing = false; + mIsHandlingComposition = true; + return NS_OK; + default: + MOZ_ASSERT_UNREACHABLE("You forgot to handle the event"); + return NS_ERROR_UNEXPECTED; + } +} +void TextEventDispatcher::EndInputTransaction( + TextEventDispatcherListener* aListener) { + if (NS_WARN_IF(IsComposing()) || NS_WARN_IF(IsDispatchingEvent())) { + return; + } + + mInputTransactionType = eNoInputTransaction; + + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + if (NS_WARN_IF(!listener)) { + return; + } + + if (NS_WARN_IF(listener != aListener)) { + return; + } + + mListener = nullptr; + listener->OnRemovedFrom(this); + UpdateNotificationRequests(); +} + +void TextEventDispatcher::OnDestroyWidget() { + mWidget = nullptr; + mHasFocus = false; + ClearNotificationRequests(); + mPendingComposition.Clear(); + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + mListener = nullptr; + mWritingMode.reset(); + mInputTransactionType = eNoInputTransaction; + if (listener) { + listener->OnRemovedFrom(this); + } +} + +nsresult TextEventDispatcher::GetState() const { + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + if (!listener) { + return NS_ERROR_NOT_INITIALIZED; + } + if (!mWidget || mWidget->Destroyed()) { + return NS_ERROR_NOT_AVAILABLE; + } + return NS_OK; +} + +void TextEventDispatcher::InitEvent(WidgetGUIEvent& aEvent) const { + aEvent.mRefPoint = LayoutDeviceIntPoint(0, 0); + aEvent.mFlags.mIsSynthesizedForTests = IsForTests(); + if (aEvent.mClass != eCompositionEventClass) { + return; + } + void* pseudoIMEContext = GetPseudoIMEContext(); + if (pseudoIMEContext) { + aEvent.AsCompositionEvent()->mNativeIMEContext.InitWithRawNativeIMEContext( + pseudoIMEContext); + } +#ifdef DEBUG + else { + MOZ_ASSERT(!XRE_IsContentProcess(), + "Why did the content process start native event transaction?"); + MOZ_ASSERT(aEvent.AsCompositionEvent()->mNativeIMEContext.IsValid(), + "Native IME context shouldn't be invalid"); + } +#endif // #ifdef DEBUG +} + +Maybe<WritingMode> TextEventDispatcher::MaybeQueryWritingModeAtSelection() + const { + if (mHasFocus || mWritingMode.isSome()) { + return mWritingMode; + } + + if (NS_WARN_IF(!mWidget)) { + return Nothing(); + } + + // If a remote content has focus and IME does not have focus, it's going to + // fail eQuerySelectedText in ContentCacheParent. For avoiding to waste + // unnecessary runtime cost and to prevent unnecessary warnings, we should + // not dispatch the event in the case. + const InputContext inputContext = mWidget->GetInputContext(); + if (XRE_IsE10sParentProcess() && inputContext.IsOriginContentProcess() && + !inputContext.mIMEState.IsEditable()) { + return Nothing(); + } + + WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText, + mWidget); + nsEventStatus status = nsEventStatus_eIgnore; + const_cast<TextEventDispatcher*>(this)->DispatchEvent( + mWidget, querySelectedTextEvent, status); + if (!querySelectedTextEvent.FoundSelection()) { + return Nothing(); + } + + return Some(querySelectedTextEvent.mReply->mWritingMode); +} + +nsresult TextEventDispatcher::DispatchEvent(nsIWidget* aWidget, + WidgetGUIEvent& aEvent, + nsEventStatus& aStatus) { + MOZ_ASSERT(!aEvent.AsInputEvent(), "Use DispatchInputEvent()"); + + RefPtr<TextEventDispatcher> kungFuDeathGrip(this); + nsCOMPtr<nsIWidget> widget(aWidget); + mDispatchingEvent++; + nsresult rv = widget->DispatchEvent(&aEvent, aStatus); + mDispatchingEvent--; + return rv; +} + +nsresult TextEventDispatcher::DispatchInputEvent(nsIWidget* aWidget, + WidgetInputEvent& aEvent, + nsEventStatus& aStatus) { + RefPtr<TextEventDispatcher> kungFuDeathGrip(this); + nsCOMPtr<nsIWidget> widget(aWidget); + mDispatchingEvent++; + + // If the event is dispatched via nsIWidget::DispatchInputEvent(), it + // sends the event to the parent process first since APZ needs to handle it + // first. However, some callers (e.g., keyboard apps on B2G and tests + // expecting synchronous dispatch) don't want this to do that. + nsresult rv = NS_OK; + if (ShouldSendInputEventToAPZ()) { + aStatus = widget->DispatchInputEvent(&aEvent).mContentStatus; + } else { + rv = widget->DispatchEvent(&aEvent, aStatus); + } + + mDispatchingEvent--; + return rv; +} + +nsresult TextEventDispatcher::StartComposition( + nsEventStatus& aStatus, const WidgetEventTime* aEventTime) { + aStatus = nsEventStatus_eIgnore; + + nsresult rv = GetState(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (NS_WARN_IF(mIsComposing)) { + return NS_ERROR_FAILURE; + } + + // When you change some members from here, you may need same change in + // BeginInputTransactionFor(). + mIsComposing = mIsHandlingComposition = true; + WidgetCompositionEvent compositionStartEvent(true, eCompositionStart, + mWidget); + InitEvent(compositionStartEvent); + if (aEventTime) { + compositionStartEvent.AssignEventTime(*aEventTime); + } + rv = DispatchEvent(mWidget, compositionStartEvent, aStatus); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +nsresult TextEventDispatcher::StartCompositionAutomaticallyIfNecessary( + nsEventStatus& aStatus, const WidgetEventTime* aEventTime) { + if (IsComposing()) { + return NS_OK; + } + + nsresult rv = StartComposition(aStatus, aEventTime); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // If started composition has already been committed, we shouldn't dispatch + // the compositionchange event. + if (!IsComposing()) { + aStatus = nsEventStatus_eConsumeNoDefault; + return NS_OK; + } + + // Note that the widget might be destroyed during a call of + // StartComposition(). In such case, we shouldn't keep dispatching next + // event. + rv = GetState(); + if (NS_FAILED(rv)) { + MOZ_ASSERT(rv != NS_ERROR_NOT_INITIALIZED, + "aDispatcher must still be initialized in this case"); + aStatus = nsEventStatus_eConsumeNoDefault; + return NS_OK; // Don't throw exception in this case + } + + aStatus = nsEventStatus_eIgnore; + return NS_OK; +} + +nsresult TextEventDispatcher::CommitComposition( + nsEventStatus& aStatus, const nsAString* aCommitString, + const WidgetEventTime* aEventTime) { + aStatus = nsEventStatus_eIgnore; + + nsresult rv = GetState(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // When there is no composition, caller shouldn't try to commit composition + // with non-existing composition string nor commit composition with empty + // string. + if (NS_WARN_IF(!IsComposing() && + (!aCommitString || aCommitString->IsEmpty()))) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIWidget> widget(mWidget); + rv = StartCompositionAutomaticallyIfNecessary(aStatus, aEventTime); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + if (aStatus == nsEventStatus_eConsumeNoDefault) { + return NS_OK; + } + + // When you change some members from here, you may need same change in + // BeginInputTransactionFor(). + + // End current composition and make this free for other IMEs. + mIsComposing = false; + + EventMessage message = + aCommitString ? eCompositionCommit : eCompositionCommitAsIs; + WidgetCompositionEvent compositionCommitEvent(true, message, widget); + InitEvent(compositionCommitEvent); + if (aEventTime) { + compositionCommitEvent.AssignEventTime(*aEventTime); + } + if (message == eCompositionCommit) { + compositionCommitEvent.mData = *aCommitString; + // If aCommitString comes from TextInputProcessor, it may be void, but + // editor requires non-void string even when it's empty. + compositionCommitEvent.mData.SetIsVoid(false); + // Don't send CRLF nor CR, replace it with LF here. + compositionCommitEvent.mData.ReplaceSubstring(u"\r\n"_ns, u"\n"_ns); + compositionCommitEvent.mData.ReplaceSubstring(u"\r"_ns, u"\n"_ns); + } + rv = DispatchEvent(widget, compositionCommitEvent, aStatus); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +nsresult TextEventDispatcher::NotifyIME( + const IMENotification& aIMENotification) { + nsresult rv = NS_ERROR_NOT_IMPLEMENTED; + + switch (aIMENotification.mMessage) { + case NOTIFY_IME_OF_FOCUS: { + mWritingMode = MaybeQueryWritingModeAtSelection(); + break; + } + case NOTIFY_IME_OF_BLUR: + mHasFocus = false; + mWritingMode.reset(); + ClearNotificationRequests(); + break; + case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED: + // If content handles composition events when native IME doesn't have + // composition, that means that we completely finished handling + // composition(s). Note that when focused content is in a remote + // process, this is sent when all dispatched composition events + // have been handled in the remote process. + if (!IsComposing()) { + mIsHandlingComposition = false; + } + break; + case NOTIFY_IME_OF_SELECTION_CHANGE: + if (mHasFocus && aIMENotification.mSelectionChangeData.HasRange()) { + mWritingMode = + Some(aIMENotification.mSelectionChangeData.GetWritingMode()); + } + break; + default: + break; + } + + // First, send the notification to current input transaction's listener. + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + if (listener) { + rv = listener->NotifyIME(this, aIMENotification); + } + + if (!mWidget) { + return rv; + } + + // If current input transaction isn't for native event handler, we should + // send the notification to the native text event dispatcher listener + // since native event handler may need to do something from + // TextEventDispatcherListener::NotifyIME() even before there is no + // input transaction yet. For example, native IME handler may need to + // create new context at receiving NOTIFY_IME_OF_FOCUS. In this case, + // mListener may not be initialized since input transaction should be + // initialized immediately before dispatching every WidgetKeyboardEvent + // and WidgetCompositionEvent (dispatching events always occurs after + // focus move). + nsCOMPtr<TextEventDispatcherListener> nativeListener = + mWidget->GetNativeTextEventDispatcherListener(); + if (listener != nativeListener && nativeListener) { + switch (aIMENotification.mMessage) { + case REQUEST_TO_COMMIT_COMPOSITION: + case REQUEST_TO_CANCEL_COMPOSITION: + // It's not necessary to notify native IME of requests. + break; + default: { + // Even if current input transaction's listener returns NS_OK or + // something, we need to notify native IME of notifications because + // when user typing after TIP does something, the changed information + // is necessary for them. + nsresult rv2 = nativeListener->NotifyIME(this, aIMENotification); + // But return the result from current listener except when the + // notification isn't handled. + if (rv == NS_ERROR_NOT_IMPLEMENTED) { + rv = rv2; + } + break; + } + } + } + + if (aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS) { + mHasFocus = true; + UpdateNotificationRequests(); + } + + return rv; +} + +void TextEventDispatcher::ClearNotificationRequests() { + mIMENotificationRequests = IMENotificationRequests(); +} + +void TextEventDispatcher::UpdateNotificationRequests() { + ClearNotificationRequests(); + + // If it doesn't has focus, no notifications are available. + if (!mHasFocus || !mWidget) { + return; + } + + // If there is a listener, its requests are necessary. + nsCOMPtr<TextEventDispatcherListener> listener = do_QueryReferent(mListener); + if (listener) { + mIMENotificationRequests = listener->GetIMENotificationRequests(); + } + + // Even if this is in non-native input transaction, native IME needs + // requests. So, add native IME requests too. + if (!IsInNativeInputTransaction()) { + nsCOMPtr<TextEventDispatcherListener> nativeListener = + mWidget->GetNativeTextEventDispatcherListener(); + if (nativeListener) { + mIMENotificationRequests |= nativeListener->GetIMENotificationRequests(); + } + } +} + +bool TextEventDispatcher::DispatchKeyboardEvent( + EventMessage aMessage, const WidgetKeyboardEvent& aKeyboardEvent, + nsEventStatus& aStatus, void* aData) { + return DispatchKeyboardEventInternal(aMessage, aKeyboardEvent, aStatus, + aData); +} + +bool TextEventDispatcher::DispatchKeyboardEventInternal( + EventMessage aMessage, const WidgetKeyboardEvent& aKeyboardEvent, + nsEventStatus& aStatus, void* aData, uint32_t aIndexOfKeypress, + bool aNeedsCallback) { + // Note that this method is also used for dispatching key events on a plugin + // because key events on a plugin should be dispatched same as normal key + // events. Then, only some handlers which need to intercept key events + // before the focused plugin (e.g., reserved shortcut key handlers) can + // consume the events. + MOZ_ASSERT( + aMessage == eKeyDown || aMessage == eKeyUp || aMessage == eKeyPress, + "Invalid aMessage value"); + nsresult rv = GetState(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + // If the key shouldn't cause keypress events, don't this patch them. + if (aMessage == eKeyPress && !aKeyboardEvent.ShouldCauseKeypressEvents()) { + return false; + } + + // Basically, key events shouldn't be dispatched during composition. + // Note that plugin process has different IME context. Therefore, we don't + // need to check our composition state when the key event is fired on a + // plugin. + if (IsComposing()) { + // However, if we need to behave like other browsers, we need the keydown + // and keyup events. Note that this behavior is also allowed by D3E spec. + // FYI: keypress events must not be fired during composition. + if (!StaticPrefs::dom_keyboardevent_dispatch_during_composition() || + aMessage == eKeyPress) { + return false; + } + // XXX If there was mOnlyContentDispatch for this case, it might be useful + // because our chrome doesn't assume that key events are fired during + // composition. + } + + WidgetKeyboardEvent keyEvent(true, aMessage, mWidget); + InitEvent(keyEvent); + keyEvent.AssignKeyEventData(aKeyboardEvent, false); + // Command arrays are not duplicated by AssignKeyEventData() due to + // both performance and footprint reasons. So, when TextInputProcessor + // emulates real text input or synthesizing keyboard events for tests, + // the arrays may be initialized all commands already. If so, we need to + // duplicate the arrays here, but we should do this only when we're + // dispatching eKeyPress events because BrowserParent::SendRealKeyEvent() + // does this only for eKeyPress event. Note that this is not required if + // we're in the main process because in the parent process, the edit commands + // will be initialized by `ExecuteEditCommands()` (when the event is handled + // by editor event listener) or `InitAllEditCommands()` (when the event is + // set to a content process). We should test whether these pathes work or + // not too. + if (XRE_IsContentProcess() && keyEvent.mIsSynthesizedByTIP) { + if (aMessage == eKeyPress) { + keyEvent.AssignCommands(aKeyboardEvent); + } else { + // Prevent retriving native edit commands if we're in a content process + // because only `eKeyPress` events coming from the main process have + // edit commands (See `BrowserParent::SendRealKeyEvent`). And also + // retriving edit commands from a content process requires synchonous + // IPC and that makes running tests slower. Therefore, we should mark + // the `eKeyPress` event does not need to retrieve edit commands anymore. + keyEvent.PreventNativeKeyBindings(); + } + } + + if (aStatus == nsEventStatus_eConsumeNoDefault) { + // If the key event should be dispatched as consumed event, marking it here. + // This is useful to prevent double action. This is intended to the system + // has already consumed the event but we need to dispatch the event for + // compatibility with older version and other browsers. So, we should not + // stop cross process forwarding of them. + keyEvent.PreventDefaultBeforeDispatch(CrossProcessForwarding::eAllow); + } + + // Corrects each member for the specific key event type. + if (keyEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING) { + MOZ_ASSERT(!aIndexOfKeypress, + "aIndexOfKeypress must be 0 for non-printable key"); + // If the keyboard event isn't caused by printable key, its charCode should + // be 0. + keyEvent.SetCharCode(0); + } else { + MOZ_DIAGNOSTIC_ASSERT_IF(aMessage == eKeyDown || aMessage == eKeyUp, + !aIndexOfKeypress); + MOZ_DIAGNOSTIC_ASSERT_IF( + aMessage == eKeyPress, + aIndexOfKeypress < std::max<size_t>(keyEvent.mKeyValue.Length(), 1)); + char16_t ch = + keyEvent.mKeyValue.IsEmpty() ? 0 : keyEvent.mKeyValue[aIndexOfKeypress]; + keyEvent.SetCharCode(static_cast<uint32_t>(ch)); + if (aMessage == eKeyPress) { + // keyCode of eKeyPress events of printable keys should be always 0. + keyEvent.mKeyCode = 0; + // eKeyPress events are dispatched for every character. + // So, each key value of eKeyPress events should be a character. + if (ch) { + if (!IS_SURROGATE(ch)) { + keyEvent.mKeyValue.Assign(ch); + } else { + const bool isHighSurrogateFollowedByLowSurrogate = + aIndexOfKeypress + 1 < keyEvent.mKeyValue.Length() && + NS_IS_HIGH_SURROGATE(ch) && + NS_IS_LOW_SURROGATE(keyEvent.mKeyValue[aIndexOfKeypress + 1]); + const bool isLowSurrogateFollowingHighSurrogate = + !isHighSurrogateFollowedByLowSurrogate && aIndexOfKeypress > 0 && + NS_IS_LOW_SURROGATE(ch) && + NS_IS_HIGH_SURROGATE(keyEvent.mKeyValue[aIndexOfKeypress - 1]); + NS_WARNING_ASSERTION(isHighSurrogateFollowedByLowSurrogate || + isLowSurrogateFollowingHighSurrogate, + "Lone surrogate input should not happen"); + if (StaticPrefs:: + dom_event_keypress_dispatch_once_per_surrogate_pair()) { + if (isHighSurrogateFollowedByLowSurrogate) { + keyEvent.mKeyValue.Assign( + keyEvent.mKeyValue.BeginReading() + aIndexOfKeypress, 2); + keyEvent.SetCharCode( + SURROGATE_TO_UCS4(ch, keyEvent.mKeyValue[1])); + } else if (isLowSurrogateFollowingHighSurrogate) { + // Although not dispatching eKeyPress event (because it's already + // dispatched for the low surrogate above), the caller should + // treat that this dispatched eKeyPress event normally so that + // return true here. + return true; + } + // Do not expose ill-formed UTF-16 string because it's a + // problematic for Rust-running-as-wasm for example. + else { + keyEvent.mKeyValue.Truncate(); + } + } else if (!StaticPrefs:: + dom_event_keypress_key_allow_lone_surrogate()) { + // If it's a high surrogate followed by a low surrogate, we should + // expose the surrogate pair with .key value. + if (isHighSurrogateFollowedByLowSurrogate) { + keyEvent.mKeyValue.Assign( + keyEvent.mKeyValue.BeginReading() + aIndexOfKeypress, 2); + } + // Do not expose low surrogate which should be handled by the + // preceding keypress event. And also do not expose ill-formed + // UTF-16 because it's a problematic for Rust-running-as-wasm for + // example. + else { + keyEvent.mKeyValue.Truncate(); + } + } else { + // Here is a path for traditional behavior. We set `.key` to + // high-surrogate and low-surrogate separately. + keyEvent.mKeyValue.Assign(ch); + } + } + } else { + keyEvent.mKeyValue.Truncate(); + } + } + } + if (aMessage == eKeyUp) { + // mIsRepeat of keyup event must be false. + keyEvent.mIsRepeat = false; + } + // mIsComposing should be initialized later. + keyEvent.mIsComposing = false; + if (mInputTransactionType == eNativeInputTransaction) { + // Copy mNativeKeyEvent here because for safety for other users of + // AssignKeyEventData(), it doesn't copy this. + keyEvent.mNativeKeyEvent = aKeyboardEvent.mNativeKeyEvent; + } else { + // If it's not a keyboard event for native key event, we should ensure that + // mNativeKeyEvent is null. + keyEvent.mNativeKeyEvent = nullptr; + } + // TODO: Manage mUniqueId here. + + // Request the alternative char codes for the key event. + // eKeyDown also needs alternative char codes because nsXBLWindowKeyHandler + // needs to check if a following keypress event is reserved by chrome for + // stopping propagation of its preceding keydown event. + keyEvent.mAlternativeCharCodes.Clear(); + if ((aMessage == eKeyDown || aMessage == eKeyPress) && + (aNeedsCallback || keyEvent.IsControl() || keyEvent.IsAlt() || + keyEvent.IsMeta())) { + nsCOMPtr<TextEventDispatcherListener> listener = + do_QueryReferent(mListener); + if (listener) { + DebugOnly<WidgetKeyboardEvent> original(keyEvent); + listener->WillDispatchKeyboardEvent(this, keyEvent, aIndexOfKeypress, + aData); + MOZ_ASSERT(keyEvent.mMessage == + static_cast<WidgetKeyboardEvent&>(original).mMessage); + MOZ_ASSERT(keyEvent.mKeyCode == + static_cast<WidgetKeyboardEvent&>(original).mKeyCode); + MOZ_ASSERT(keyEvent.mLocation == + static_cast<WidgetKeyboardEvent&>(original).mLocation); + MOZ_ASSERT(keyEvent.mIsRepeat == + static_cast<WidgetKeyboardEvent&>(original).mIsRepeat); + MOZ_ASSERT(keyEvent.mIsComposing == + static_cast<WidgetKeyboardEvent&>(original).mIsComposing); + MOZ_ASSERT(keyEvent.mKeyNameIndex == + static_cast<WidgetKeyboardEvent&>(original).mKeyNameIndex); + MOZ_ASSERT(keyEvent.mCodeNameIndex == + static_cast<WidgetKeyboardEvent&>(original).mCodeNameIndex); + MOZ_ASSERT(keyEvent.mKeyValue == + static_cast<WidgetKeyboardEvent&>(original).mKeyValue); + MOZ_ASSERT(keyEvent.mCodeValue == + static_cast<WidgetKeyboardEvent&>(original).mCodeValue); + } + } + + if (StaticPrefs:: + dom_keyboardevent_keypress_dispatch_non_printable_keys_only_system_group_in_content() && + keyEvent.mMessage == eKeyPress && + !keyEvent.ShouldKeyPressEventBeFiredOnContent()) { + // Note that even if we set it to true, this may be overwritten by + // PresShell::DispatchEventToDOM(). + keyEvent.mFlags.mOnlySystemGroupDispatchInContent = true; + } + + // If an editable element has focus and we're in the parent process, we should + // retrieve native key bindings right now because even if it matches with a + // reserved shortcut key, it should be handled by the editor. + if (XRE_IsParentProcess() && mHasFocus && + (aMessage == eKeyDown || aMessage == eKeyPress)) { + keyEvent.InitAllEditCommands(mWritingMode); + } + + DispatchInputEvent(mWidget, keyEvent, aStatus); + return true; +} + +bool TextEventDispatcher::MaybeDispatchKeypressEvents( + const WidgetKeyboardEvent& aKeyboardEvent, nsEventStatus& aStatus, + void* aData, bool aNeedsCallback) { + // If the key event was consumed, keypress event shouldn't be fired. + if (aStatus == nsEventStatus_eConsumeNoDefault) { + return false; + } + + // If the key shouldn't cause keypress events, don't fire them. + if (!aKeyboardEvent.ShouldCauseKeypressEvents()) { + return false; + } + + // If the key isn't a printable key or just inputting one character or + // no character, we should dispatch only one keypress. Otherwise, i.e., + // if the key is a printable key and inputs multiple characters, keypress + // event should be dispatched the count of inputting characters times. + size_t keypressCount = + aKeyboardEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING + ? 1 + : std::max(static_cast<nsAString::size_type>(1), + aKeyboardEvent.mKeyValue.Length()); + bool isDispatched = false; + bool consumed = false; + for (size_t i = 0; i < keypressCount; i++) { + aStatus = nsEventStatus_eIgnore; + if (!DispatchKeyboardEventInternal(eKeyPress, aKeyboardEvent, aStatus, + aData, i, aNeedsCallback)) { + // The widget must have been gone. + break; + } + isDispatched = true; + if (!consumed) { + consumed = (aStatus == nsEventStatus_eConsumeNoDefault); + } + } + + // If one of the keypress event was consumed, return ConsumeNoDefault. + if (consumed) { + aStatus = nsEventStatus_eConsumeNoDefault; + } + + return isDispatched; +} + +/****************************************************************************** + * TextEventDispatcher::PendingComposition + *****************************************************************************/ + +TextEventDispatcher::PendingComposition::PendingComposition() { Clear(); } + +void TextEventDispatcher::PendingComposition::Clear() { + mString.Truncate(); + mClauses = nullptr; + mCaret.mRangeType = TextRangeType::eUninitialized; + mReplacedNativeLineBreakers = false; +} + +void TextEventDispatcher::PendingComposition::EnsureClauseArray() { + if (mClauses) { + return; + } + mClauses = new TextRangeArray(); +} + +nsresult TextEventDispatcher::PendingComposition::SetString( + const nsAString& aString) { + MOZ_ASSERT(!mReplacedNativeLineBreakers); + mString = aString; + return NS_OK; +} + +nsresult TextEventDispatcher::PendingComposition::AppendClause( + uint32_t aLength, TextRangeType aTextRangeType) { + MOZ_ASSERT(!mReplacedNativeLineBreakers); + + if (NS_WARN_IF(!aLength)) { + return NS_ERROR_INVALID_ARG; + } + + switch (aTextRangeType) { + case TextRangeType::eRawClause: + case TextRangeType::eSelectedRawClause: + case TextRangeType::eConvertedClause: + case TextRangeType::eSelectedClause: { + EnsureClauseArray(); + TextRange textRange; + textRange.mStartOffset = + mClauses->IsEmpty() ? 0 : mClauses->LastElement().mEndOffset; + textRange.mEndOffset = textRange.mStartOffset + aLength; + textRange.mRangeType = aTextRangeType; + mClauses->AppendElement(textRange); + return NS_OK; + } + default: + return NS_ERROR_INVALID_ARG; + } +} + +nsresult TextEventDispatcher::PendingComposition::SetCaret(uint32_t aOffset, + uint32_t aLength) { + MOZ_ASSERT(!mReplacedNativeLineBreakers); + + mCaret.mStartOffset = aOffset; + mCaret.mEndOffset = mCaret.mStartOffset + aLength; + mCaret.mRangeType = TextRangeType::eCaret; + return NS_OK; +} + +nsresult TextEventDispatcher::PendingComposition::Set( + const nsAString& aString, const TextRangeArray* aRanges) { + Clear(); + + nsresult rv = SetString(aString); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (!aRanges || aRanges->IsEmpty()) { + // Create dummy range if mString isn't empty. + if (!mString.IsEmpty()) { + rv = AppendClause(mString.Length(), TextRangeType::eRawClause); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + ReplaceNativeLineBreakers(); + } + return NS_OK; + } + + // Adjust offsets in the ranges for XP linefeed character (only \n). + for (uint32_t i = 0; i < aRanges->Length(); ++i) { + TextRange range = aRanges->ElementAt(i); + if (range.mRangeType == TextRangeType::eCaret) { + mCaret = range; + } else { + EnsureClauseArray(); + mClauses->AppendElement(range); + } + } + ReplaceNativeLineBreakers(); + return NS_OK; +} + +void TextEventDispatcher::PendingComposition::ReplaceNativeLineBreakers() { + mReplacedNativeLineBreakers = true; + + // If the composition string is empty, we don't need to do anything. + if (mString.IsEmpty()) { + return; + } + + nsAutoString nativeString(mString); + // Don't expose CRLF nor CR to web contents, instead, use LF. + mString.ReplaceSubstring(u"\r\n"_ns, u"\n"_ns); + mString.ReplaceSubstring(u"\r"_ns, u"\n"_ns); + + // If the length isn't changed, we don't need to adjust any offset and length + // of mClauses nor mCaret. + if (nativeString.Length() == mString.Length()) { + return; + } + + if (mClauses) { + for (TextRange& clause : *mClauses) { + AdjustRange(clause, nativeString); + } + } + if (mCaret.mRangeType == TextRangeType::eCaret) { + AdjustRange(mCaret, nativeString); + } +} + +// static +void TextEventDispatcher::PendingComposition::AdjustRange( + TextRange& aRange, const nsAString& aNativeString) { + TextRange nativeRange = aRange; + // XXX Following code wastes runtime cost because this causes computing + // mStartOffset for each clause from the start of composition string. + // If we'd make TextRange have only its length, we don't need to do + // this. However, this must not be so serious problem because + // composition string is usually short and separated as a few clauses. + if (nativeRange.mStartOffset > 0) { + nsAutoString preText(Substring(aNativeString, 0, nativeRange.mStartOffset)); + preText.ReplaceSubstring(u"\r\n"_ns, u"\n"_ns); + aRange.mStartOffset = preText.Length(); + } + if (nativeRange.Length() == 0) { + aRange.mEndOffset = aRange.mStartOffset; + } else { + nsAutoString clause(Substring(aNativeString, nativeRange.mStartOffset, + nativeRange.Length())); + clause.ReplaceSubstring(u"\r\n"_ns, u"\n"_ns); + aRange.mEndOffset = aRange.mStartOffset + clause.Length(); + } +} + +nsresult TextEventDispatcher::PendingComposition::Flush( + TextEventDispatcher* aDispatcher, nsEventStatus& aStatus, + const WidgetEventTime* aEventTime) { + aStatus = nsEventStatus_eIgnore; + + nsresult rv = aDispatcher->GetState(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (mClauses && !mClauses->IsEmpty() && + mClauses->LastElement().mEndOffset != mString.Length()) { + NS_WARNING( + "Sum of length of the all clauses must be same as the string " + "length"); + Clear(); + return NS_ERROR_ILLEGAL_VALUE; + } + if (mCaret.mRangeType == TextRangeType::eCaret) { + if (mCaret.mEndOffset > mString.Length()) { + NS_WARNING("Caret position is out of the composition string"); + Clear(); + return NS_ERROR_ILLEGAL_VALUE; + } + EnsureClauseArray(); + mClauses->AppendElement(mCaret); + } + + // If the composition string is set without Set(), we need to replace native + // line breakers in the composition string with XP line breaker. + if (!mReplacedNativeLineBreakers) { + ReplaceNativeLineBreakers(); + } + + RefPtr<TextEventDispatcher> kungFuDeathGrip(aDispatcher); + nsCOMPtr<nsIWidget> widget(aDispatcher->mWidget); + WidgetCompositionEvent compChangeEvent(true, eCompositionChange, widget); + aDispatcher->InitEvent(compChangeEvent); + if (aEventTime) { + compChangeEvent.AssignEventTime(*aEventTime); + } + compChangeEvent.mData = mString; + // If mString comes from TextInputProcessor, it may be void, but editor + // requires non-void string even when it's empty. + compChangeEvent.mData.SetIsVoid(false); + if (mClauses) { + MOZ_ASSERT(!mClauses->IsEmpty(), + "mClauses must be non-empty array when it's not nullptr"); + compChangeEvent.mRanges = mClauses; + } + + // While this method dispatches a composition event, some other event handler + // cause more clauses to be added. So, we should clear pending composition + // before dispatching the event. + Clear(); + + rv = aDispatcher->StartCompositionAutomaticallyIfNecessary(aStatus, + aEventTime); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + if (aStatus == nsEventStatus_eConsumeNoDefault) { + return NS_OK; + } + rv = aDispatcher->DispatchEvent(widget, compChangeEvent, aStatus); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +} // namespace widget +} // namespace mozilla |