diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/events/IMEContentObserver.cpp | 2173 |
1 files changed, 2173 insertions, 0 deletions
diff --git a/dom/events/IMEContentObserver.cpp b/dom/events/IMEContentObserver.cpp new file mode 100644 index 0000000000..0a63a8b841 --- /dev/null +++ b/dom/events/IMEContentObserver.cpp @@ -0,0 +1,2173 @@ +/* -*- 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/Logging.h" + +#include "ContentEventHandler.h" +#include "IMEContentObserver.h" +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/EventStateManager.h" +#include "mozilla/IMEStateManager.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/PresShell.h" +#include "mozilla/TextComposition.h" +#include "mozilla/TextEvents.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/Selection.h" +#include "nsContentUtils.h" +#include "nsGkAtoms.h" +#include "nsAtom.h" +#include "nsDocShell.h" +#include "nsIContent.h" +#include "mozilla/dom/Document.h" +#include "nsIFrame.h" +#include "nsINode.h" +#include "nsISelectionController.h" +#include "nsISupports.h" +#include "nsIWeakReferenceUtils.h" +#include "nsIWidget.h" +#include "nsPresContext.h" +#include "nsRange.h" +#include "nsRefreshDriver.h" +#include "WritingModes.h" + +namespace mozilla { + +using NodePosition = ContentEventHandler::NodePosition; +using NodePositionBefore = ContentEventHandler::NodePositionBefore; + +using namespace dom; +using namespace widget; + +LazyLogModule sIMECOLog("IMEContentObserver"); + +static const char* ToChar(bool aBool) { return aBool ? "true" : "false"; } + +// This method determines the node to use for the point before the current node. +// If you have the following aContent and aContainer, and want to represent the +// following point for `NodePosition` or `RangeBoundary`: +// +// <parent> {node} {node} | {node} </parent> +// ^ ^ ^ +// aContainer point aContent +// +// This function will shift `aContent` to the left into the format which +// `NodePosition` and `RangeBoundary` use: +// +// <parent> {node} {node} | {node} </parent> +// ^ ^ ^ +// aContainer result point +static nsIContent* PointBefore(nsINode* aContainer, nsIContent* aContent) { + if (aContent) { + return aContent->GetPreviousSibling(); + } + return aContainer->GetLastChild(); +} + +/****************************************************************************** + * mozilla::IMEContentObserver + ******************************************************************************/ + +NS_IMPL_CYCLE_COLLECTION_CLASS(IMEContentObserver) + +// Note that we don't need to add mFirstAddedContainer nor +// mLastAddedContainer to cycle collection because they are non-null only +// during short time and shouldn't be touched while they are non-null. + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(IMEContentObserver) + nsAutoScriptBlocker scriptBlocker; + + tmp->NotifyIMEOfBlur(); + tmp->UnregisterObservers(); + + NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelection) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootElement) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditableNode) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocShell) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditorBase) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentObserver) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mEndOfAddedTextCache.mContainerNode) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mStartOfRemovingTextRangeCache.mContainerNode) + NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE + + tmp->mIMENotificationRequests = nullptr; + tmp->mESM = nullptr; +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IMEContentObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWidget) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusedWidget) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelection) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootElement) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditableNode) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocShell) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditorBase) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndOfAddedTextCache.mContainerNode) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE( + mStartOfRemovingTextRangeCache.mContainerNode) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IMEContentObserver) + NS_INTERFACE_MAP_ENTRY(nsIMutationObserver) + NS_INTERFACE_MAP_ENTRY(nsIReflowObserver) + NS_INTERFACE_MAP_ENTRY(nsIScrollObserver) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIReflowObserver) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(IMEContentObserver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(IMEContentObserver) + +IMEContentObserver::IMEContentObserver() + : mESM(nullptr), + mIMENotificationRequests(nullptr), + mSendingNotification(NOTIFY_IME_OF_NOTHING), + mIsObserving(false), + mIMEHasFocus(false), + mNeedsToNotifyIMEOfFocusSet(false), + mNeedsToNotifyIMEOfTextChange(false), + mNeedsToNotifyIMEOfSelectionChange(false), + mNeedsToNotifyIMEOfPositionChange(false), + mNeedsToNotifyIMEOfCompositionEventHandled(false), + mIsHandlingQueryContentEvent(false) { +#ifdef DEBUG + mTextChangeData.Test(); +#endif +} + +void IMEContentObserver::Init(nsIWidget& aWidget, nsPresContext& aPresContext, + Element* aElement, EditorBase& aEditorBase) { + State state = GetState(); + if (NS_WARN_IF(state == eState_Observing)) { + return; // Nothing to do. + } + + bool firstInitialization = state != eState_StoppedObserving; + if (!firstInitialization) { + // If this is now trying to initialize with new contents, all observers + // should be registered again for simpler implementation. + UnregisterObservers(); + Clear(); + } + + mESM = aPresContext.EventStateManager(); + mESM->OnStartToObserveContent(this); + + mWidget = &aWidget; + mIMENotificationRequests = &mWidget->IMENotificationRequestsRef(); + + if (!InitWithEditor(aPresContext, aElement, aEditorBase)) { + MOZ_LOG(sIMECOLog, LogLevel::Error, + ("0x%p Init() FAILED, due to InitWithEditor() " + "failure", + this)); + Clear(); + return; + } + + if (firstInitialization) { + // Now, try to send NOTIFY_IME_OF_FOCUS to IME via the widget. + MaybeNotifyIMEOfFocusSet(); + // When this is called first time, IME has not received NOTIFY_IME_OF_FOCUS + // yet since NOTIFY_IME_OF_FOCUS will be sent to widget asynchronously. + // So, we need to do nothing here. After NOTIFY_IME_OF_FOCUS has been + // sent, OnIMEReceivedFocus() will be called and content, selection and/or + // position changes will be observed + return; + } + + // When this is called after editor reframing (i.e., the root editable node + // is also recreated), IME has usually received NOTIFY_IME_OF_FOCUS. In this + // case, we need to restart to observe content, selection and/or position + // changes in new root editable node. + ObserveEditableNode(); + + if (!NeedsToNotifyIMEOfSomething()) { + return; + } + + // Some change events may wait to notify IME because this was being + // initialized. It is the time to flush them. + FlushMergeableNotifications(); +} + +void IMEContentObserver::OnIMEReceivedFocus() { + // While Init() notifies IME of focus, pending layout may be flushed + // because the notification may cause querying content. Then, recursive + // call of Init() with the latest content may occur. In such case, we + // shouldn't keep first initialization which notified IME of focus. + if (GetState() != eState_Initializing) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p OnIMEReceivedFocus(), " + "but the state is not \"initializing\", so does nothing", + this)); + return; + } + + // NOTIFY_IME_OF_FOCUS might cause recreating IMEContentObserver + // instance via IMEStateManager::UpdateIMEState(). So, this + // instance might already have been destroyed, check it. + if (!mRootElement) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p OnIMEReceivedFocus(), " + "but mRootElement has already been cleared, so does nothing", + this)); + return; + } + + // Start to observe which is needed by IME when IME actually has focus. + ObserveEditableNode(); + + if (!NeedsToNotifyIMEOfSomething()) { + return; + } + + // Some change events may wait to notify IME because this was being + // initialized. It is the time to flush them. + FlushMergeableNotifications(); +} + +bool IMEContentObserver::InitWithEditor(nsPresContext& aPresContext, + Element* aElement, + EditorBase& aEditorBase) { + mEditableNode = IMEStateManager::GetRootEditableNode(aPresContext, aElement); + if (NS_WARN_IF(!mEditableNode)) { + return false; + } + + mEditorBase = &aEditorBase; + + RefPtr<PresShell> presShell = aPresContext.GetPresShell(); + + // get selection and root content + nsCOMPtr<nsISelectionController> selCon; + if (mEditableNode->IsContent()) { + nsIFrame* frame = mEditableNode->AsContent()->GetPrimaryFrame(); + if (NS_WARN_IF(!frame)) { + return false; + } + + frame->GetSelectionController(&aPresContext, getter_AddRefs(selCon)); + } else { + // mEditableNode is a document + selCon = presShell; + } + + if (NS_WARN_IF(!selCon)) { + return false; + } + + mSelection = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL); + if (NS_WARN_IF(!mSelection)) { + return false; + } + + if (mEditorBase->IsTextEditor()) { + mRootElement = mEditorBase->GetRoot(); // The anonymous <div> + MOZ_ASSERT(mRootElement); + MOZ_ASSERT(mRootElement->GetFirstChild()); + if (auto* text = Text::FromNodeOrNull( + mRootElement ? mRootElement->GetFirstChild() : nullptr)) { + mTextControlValueLength = ContentEventHandler::GetNativeTextLength(*text); + } + } else if (const nsRange* selRange = mSelection->GetRangeAt(0)) { + if (NS_WARN_IF(!selRange->GetStartContainer())) { + return false; + } + + nsCOMPtr<nsINode> startContainer = selRange->GetStartContainer(); + mRootElement = Element::FromNodeOrNull( + startContainer->GetSelectionRootContent(presShell)); + } else { + nsCOMPtr<nsINode> editableNode = mEditableNode; + mRootElement = Element::FromNodeOrNull( + editableNode->GetSelectionRootContent(presShell)); + } + if (!mRootElement && mEditableNode->IsDocument()) { + // The document node is editable, but there are no contents, this document + // is not editable. + return false; + } + + if (NS_WARN_IF(!mRootElement)) { + return false; + } + + mDocShell = aPresContext.GetDocShell(); + if (NS_WARN_IF(!mDocShell)) { + return false; + } + + mDocumentObserver = new DocumentObserver(*this); + + return true; +} + +void IMEContentObserver::Clear() { + mEditorBase = nullptr; + mSelection = nullptr; + mEditableNode = nullptr; + mRootElement = nullptr; + mDocShell = nullptr; + // Should be safe to clear mDocumentObserver here even though it grabs + // this instance in most cases because this is called by Init() or Destroy(). + // The callers of Init() grab this instance with local RefPtr. + // The caller of Destroy() also grabs this instance with local RefPtr. + // So, this won't cause refcount of this instance become 0. + mDocumentObserver = nullptr; +} + +void IMEContentObserver::ObserveEditableNode() { + MOZ_RELEASE_ASSERT(mSelection); + MOZ_RELEASE_ASSERT(mRootElement); + MOZ_RELEASE_ASSERT(GetState() != eState_Observing); + + // If this is called before sending NOTIFY_IME_OF_FOCUS (it's possible when + // the editor is reframed before sending NOTIFY_IME_OF_FOCUS asynchronously), + // the notification requests of mWidget may be different from after the widget + // receives NOTIFY_IME_OF_FOCUS. So, this should be called again by + // OnIMEReceivedFocus() which is called after sending NOTIFY_IME_OF_FOCUS. + if (!mIMEHasFocus) { + MOZ_ASSERT(!mWidget || mNeedsToNotifyIMEOfFocusSet || + mSendingNotification == NOTIFY_IME_OF_FOCUS, + "Wow, OnIMEReceivedFocus() won't be called?"); + return; + } + + mIsObserving = true; + if (mEditorBase) { + mEditorBase->SetIMEContentObserver(this); + } + + mRootElement->AddMutationObserver(this); + // If it's in a document (should be so), we can use document observer to + // reduce redundant computation of text change offsets. + Document* doc = mRootElement->GetComposedDoc(); + if (doc) { + RefPtr<DocumentObserver> documentObserver = mDocumentObserver; + documentObserver->Observe(doc); + } + + if (mDocShell) { + // Add scroll position listener and reflow observer to detect position + // and size changes + mDocShell->AddWeakScrollObserver(this); + mDocShell->AddWeakReflowObserver(this); + } +} + +void IMEContentObserver::NotifyIMEOfBlur() { + // Prevent any notifications to be sent IME. + nsCOMPtr<nsIWidget> widget; + mWidget.swap(widget); + mIMENotificationRequests = nullptr; + + // If we hasn't been set focus, we shouldn't send blur notification to IME. + if (!mIMEHasFocus) { + return; + } + + // mWidget must have been non-nullptr if IME has focus. + MOZ_RELEASE_ASSERT(widget); + + RefPtr<IMEContentObserver> kungFuDeathGrip(this); + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p NotifyIMEOfBlur(), sending NOTIFY_IME_OF_BLUR", this)); + + // For now, we need to send blur notification in any condition because + // we don't have any simple ways to send blur notification asynchronously. + // After this call, Destroy() or Unlink() will stop observing the content + // and forget everything. Therefore, if it's not safe to send notification + // when script blocker is unlocked, we cannot send blur notification after + // that and before next focus notification. + // Anyway, as far as we know, IME doesn't try to query content when it loses + // focus. So, this may not cause any problem. + mIMEHasFocus = false; + IMEStateManager::NotifyIME(IMENotification(NOTIFY_IME_OF_BLUR), widget); + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p NotifyIMEOfBlur(), sent NOTIFY_IME_OF_BLUR", this)); +} + +void IMEContentObserver::UnregisterObservers() { + if (!mIsObserving) { + return; + } + mIsObserving = false; + + if (mEditorBase) { + mEditorBase->SetIMEContentObserver(nullptr); + } + + if (mSelection) { + mSelectionData.Clear(); + mFocusedWidget = nullptr; + } + + if (mRootElement) { + mRootElement->RemoveMutationObserver(this); + } + + if (mDocumentObserver) { + RefPtr<DocumentObserver> documentObserver = mDocumentObserver; + documentObserver->StopObserving(); + } + + if (mDocShell) { + mDocShell->RemoveWeakScrollObserver(this); + mDocShell->RemoveWeakReflowObserver(this); + } +} + +nsPresContext* IMEContentObserver::GetPresContext() const { + return mESM ? mESM->GetPresContext() : nullptr; +} + +void IMEContentObserver::Destroy() { + // WARNING: When you change this method, you have to check Unlink() too. + + // Note that don't send any notifications later from here. I.e., notify + // IMEStateManager of the blur synchronously because IMEStateManager needs to + // stop notifying the main process if this is requested by the main process. + NotifyIMEOfBlur(); + UnregisterObservers(); + Clear(); + + mWidget = nullptr; + mIMENotificationRequests = nullptr; + + if (mESM) { + mESM->OnStopObservingContent(this); + mESM = nullptr; + } +} + +bool IMEContentObserver::Destroyed() const { return !mWidget; } + +void IMEContentObserver::DisconnectFromEventStateManager() { mESM = nullptr; } + +bool IMEContentObserver::MaybeReinitialize(nsIWidget& aWidget, + nsPresContext& aPresContext, + Element* aElement, + EditorBase& aEditorBase) { + if (!IsObservingContent(aPresContext, aElement)) { + return false; + } + + if (GetState() == eState_StoppedObserving) { + Init(aWidget, aPresContext, aElement, aEditorBase); + } + return IsManaging(aPresContext, aElement); +} + +bool IMEContentObserver::IsManaging(const nsPresContext& aPresContext, + const Element* aElement) const { + return GetState() == eState_Observing && + IsObservingContent(aPresContext, aElement); +} + +bool IMEContentObserver::IsBeingInitializedFor( + const nsPresContext& aPresContext, const Element* aElement) const { + return GetState() == eState_Initializing && + IsObservingContent(aPresContext, aElement); +} + +bool IMEContentObserver::IsManaging( + const TextComposition& aTextComposition) const { + if (GetState() != eState_Observing) { + return false; + } + nsPresContext* const presContext = aTextComposition.GetPresContext(); + if (NS_WARN_IF(!presContext)) { + return false; + } + if (presContext != GetPresContext()) { + return false; // observing different document + } + return IsObservingContent( + *presContext, + Element::FromNodeOrNull(aTextComposition.GetEventTargetNode())); +} + +IMEContentObserver::State IMEContentObserver::GetState() const { + if (!mSelection || !mRootElement || !mEditableNode) { + return eState_NotObserving; // failed to initialize or finalized. + } + if (!mRootElement->IsInComposedDoc()) { + // the focused editor has already been reframed. + return eState_StoppedObserving; + } + return mIsObserving ? eState_Observing : eState_Initializing; +} + +bool IMEContentObserver::IsObservingContent(const nsPresContext& aPresContext, + const Element* aElement) const { + return mEditableNode == + IMEStateManager::GetRootEditableNode(aPresContext, aElement); +} + +bool IMEContentObserver::IsEditorHandlingEventForComposition() const { + if (!mWidget) { + return false; + } + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(mWidget); + if (!composition) { + return false; + } + return composition->IsEditorHandlingEvent(); +} + +bool IMEContentObserver::IsEditorComposing() const { + // Note that don't use TextComposition here. The important thing is, + // whether the editor already started to handle composition because + // web contents can change selection, text content and/or something from + // compositionstart event listener which is run before EditorBase handles it. + if (NS_WARN_IF(!mEditorBase)) { + return false; + } + return mEditorBase->IsIMEComposing(); +} + +nsresult IMEContentObserver::GetSelectionAndRoot(Selection** aSelection, + Element** aRootElement) const { + if (!mEditableNode || !mSelection) { + return NS_ERROR_NOT_AVAILABLE; + } + + NS_ASSERTION(mSelection && mRootElement, "uninitialized content observer"); + NS_ADDREF(*aSelection = mSelection); + NS_ADDREF(*aRootElement = mRootElement); + return NS_OK; +} + +void IMEContentObserver::OnSelectionChange(Selection& aSelection) { + if (!mIsObserving) { + return; + } + + if (mWidget) { + bool causedByComposition = IsEditorHandlingEventForComposition(); + bool causedBySelectionEvent = TextComposition::IsHandlingSelectionEvent(); + bool duringComposition = IsEditorComposing(); + MaybeNotifyIMEOfSelectionChange(causedByComposition, causedBySelectionEvent, + duringComposition); + } +} + +void IMEContentObserver::ScrollPositionChanged() { + if (!NeedsPositionChangeNotification()) { + return; + } + + MaybeNotifyIMEOfPositionChange(); +} + +NS_IMETHODIMP +IMEContentObserver::Reflow(DOMHighResTimeStamp aStart, + DOMHighResTimeStamp aEnd) { + if (!NeedsPositionChangeNotification()) { + return NS_OK; + } + + MaybeNotifyIMEOfPositionChange(); + return NS_OK; +} + +NS_IMETHODIMP +IMEContentObserver::ReflowInterruptible(DOMHighResTimeStamp aStart, + DOMHighResTimeStamp aEnd) { + if (!NeedsPositionChangeNotification()) { + return NS_OK; + } + + MaybeNotifyIMEOfPositionChange(); + return NS_OK; +} + +nsresult IMEContentObserver::HandleQueryContentEvent( + WidgetQueryContentEvent* aEvent) { + // If the instance has normal selection cache and the query event queries + // normal selection's range, it should use the cached selection which was + // sent to the widget. However, if this instance has already received new + // selection change notification but hasn't updated the cache yet (i.e., + // not sending selection change notification to IME, don't use the cached + // value. Note that don't update selection cache here since if you update + // selection cache here, IMENotificationSender won't notify IME of selection + // change because it looks like that the selection isn't actually changed. + const bool isSelectionCacheAvailable = aEvent->mUseNativeLineBreak && + mSelectionData.IsInitialized() && + !mNeedsToNotifyIMEOfSelectionChange; + if (isSelectionCacheAvailable && aEvent->mMessage == eQuerySelectedText && + aEvent->mInput.mSelectionType == SelectionType::eNormal) { + aEvent->EmplaceReply(); + if (mSelectionData.HasRange()) { + aEvent->mReply->mOffsetAndData.emplace(mSelectionData.mOffset, + mSelectionData.String(), + OffsetAndDataFor::SelectedString); + aEvent->mReply->mReversed = mSelectionData.mReversed; + } + aEvent->mReply->mContentsRoot = mRootElement; + aEvent->mReply->mWritingMode = mSelectionData.GetWritingMode(); + // The selection cache in IMEContentObserver must always have been in + // an editing host (or an editable annoymous <div> element). Therefore, + // we set mIsEditableContent to true here even though it's already been + // blurred or changed its editable state but the selection cache has not + // been invalidated yet. + aEvent->mReply->mIsEditableContent = true; + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p HandleQueryContentEvent(aEvent={ " + "mMessage=%s, mReply=%s })", + this, ToChar(aEvent->mMessage), ToString(aEvent->mReply).c_str())); + return NS_OK; + } + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p HandleQueryContentEvent(aEvent={ mMessage=%s })", this, + ToChar(aEvent->mMessage))); + + // If we can make the event's input offset absolute with TextComposition or + // mSelection, we should set it here for reducing the cost of computing + // selection start offset. If ContentEventHandler receives a + // WidgetQueryContentEvent whose input offset is relative to insertion point, + // it computes current selection start offset (this may be expensive) and + // make the offset absolute value itself. + // Note that calling MakeOffsetAbsolute() makes the event a query event with + // absolute offset. So, ContentEventHandler doesn't pay any additional cost + // after calling MakeOffsetAbsolute() here. + if (aEvent->mInput.mRelativeToInsertionPoint && + aEvent->mInput.IsValidEventMessage(aEvent->mMessage)) { + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(aEvent->mWidget); + if (composition) { + uint32_t compositionStart = composition->NativeOffsetOfStartComposition(); + if (NS_WARN_IF(!aEvent->mInput.MakeOffsetAbsolute(compositionStart))) { + return NS_ERROR_FAILURE; + } + } else if (isSelectionCacheAvailable && mSelectionData.HasRange()) { + const uint32_t selectionStart = mSelectionData.mOffset; + if (NS_WARN_IF(!aEvent->mInput.MakeOffsetAbsolute(selectionStart))) { + return NS_ERROR_FAILURE; + } + } + } + + AutoRestore<bool> handling(mIsHandlingQueryContentEvent); + mIsHandlingQueryContentEvent = true; + ContentEventHandler handler(GetPresContext()); + nsresult rv = handler.HandleQueryContentEvent(aEvent); + if (NS_WARN_IF(Destroyed())) { + // If this has already destroyed during querying the content, the query + // is outdated even if it's succeeded. So, make the query fail. + aEvent->mReply.reset(); + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p HandleQueryContentEvent(), WARNING, " + "IMEContentObserver has been destroyed during the query, " + "making the query fail", + this)); + return rv; + } + + if (aEvent->Succeeded() && + NS_WARN_IF(aEvent->mReply->mContentsRoot != mRootElement)) { + // Focus has changed unexpectedly, so make the query fail. + aEvent->mReply.reset(); + } + return rv; +} + +nsresult IMEContentObserver::MaybeHandleSelectionEvent( + nsPresContext* aPresContext, WidgetSelectionEvent* aEvent) { + MOZ_ASSERT(aEvent); + MOZ_ASSERT(aEvent->mMessage == eSetSelection); + NS_ASSERTION(!mNeedsToNotifyIMEOfSelectionChange, + "Selection cache has not been updated yet"); + + MOZ_LOG( + sIMECOLog, LogLevel::Debug, + ("0x%p MaybeHandleSelectionEvent(aEvent={ " + "mMessage=%s, mOffset=%u, mLength=%u, mReversed=%s, " + "mExpandToClusterBoundary=%s, mUseNativeLineBreak=%s }), " + "mSelectionData=%s", + this, ToChar(aEvent->mMessage), aEvent->mOffset, aEvent->mLength, + ToChar(aEvent->mReversed), ToChar(aEvent->mExpandToClusterBoundary), + ToChar(aEvent->mUseNativeLineBreak), ToString(mSelectionData).c_str())); + + // When we have Selection cache, and the caller wants to set same selection + // range, we shouldn't try to compute same range because it may be impossible + // if the range boundary is around element boundaries which won't be + // serialized with line breaks like close tags of inline elements. In that + // case, inserting new text at different point may be different from intention + // of users or web apps which set current selection. + // FIXME: We cache only selection data computed with native line breaker + // lengths. Perhaps, we should improve the struct to have both data of + // offset and length. E.g., adding line break counts for both offset and + // length. + if (!mNeedsToNotifyIMEOfSelectionChange && aEvent->mUseNativeLineBreak && + mSelectionData.IsInitialized() && mSelectionData.HasRange() && + mSelectionData.StartOffset() == aEvent->mOffset && + mSelectionData.Length() == aEvent->mLength) { + if (RefPtr<Selection> selection = mSelection) { + selection->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION, + ScrollAxis(), ScrollAxis(), 0); + } + aEvent->mSucceeded = true; + return NS_OK; + } + + ContentEventHandler handler(aPresContext); + return handler.OnSelectionEvent(aEvent); +} + +bool IMEContentObserver::OnMouseButtonEvent(nsPresContext& aPresContext, + WidgetMouseEvent& aMouseEvent) { + if (!mIMENotificationRequests || + !mIMENotificationRequests->WantMouseButtonEventOnChar()) { + return false; + } + if (!aMouseEvent.IsTrusted() || aMouseEvent.DefaultPrevented() || + !aMouseEvent.mWidget) { + return false; + } + // Now, we need to notify only mouse down and mouse up event. + switch (aMouseEvent.mMessage) { + case eMouseUp: + case eMouseDown: + break; + default: + return false; + } + if (NS_WARN_IF(!mWidget) || NS_WARN_IF(mWidget->Destroyed())) { + return false; + } + + WidgetQueryContentEvent queryCharAtPointEvent(true, eQueryCharacterAtPoint, + aMouseEvent.mWidget); + queryCharAtPointEvent.mRefPoint = aMouseEvent.mRefPoint; + ContentEventHandler handler(&aPresContext); + handler.OnQueryCharacterAtPoint(&queryCharAtPointEvent); + if (NS_WARN_IF(queryCharAtPointEvent.Failed()) || + queryCharAtPointEvent.DidNotFindChar()) { + return false; + } + + // The widget might be destroyed during querying the content since it + // causes flushing layout. + if (!mWidget || NS_WARN_IF(mWidget->Destroyed())) { + return false; + } + + // The result character rect is relative to the top level widget. + // We should notify it with offset in the widget. + nsIWidget* topLevelWidget = mWidget->GetTopLevelWidget(); + if (topLevelWidget && topLevelWidget != mWidget) { + queryCharAtPointEvent.mReply->mRect.MoveBy( + topLevelWidget->WidgetToScreenOffset() - + mWidget->WidgetToScreenOffset()); + } + // The refPt is relative to its widget. + // We should notify it with offset in the widget. + if (aMouseEvent.mWidget != mWidget) { + queryCharAtPointEvent.mRefPoint += + aMouseEvent.mWidget->WidgetToScreenOffset() - + mWidget->WidgetToScreenOffset(); + } + + IMENotification notification(NOTIFY_IME_OF_MOUSE_BUTTON_EVENT); + notification.mMouseButtonEventData.mEventMessage = aMouseEvent.mMessage; + notification.mMouseButtonEventData.mOffset = + queryCharAtPointEvent.mReply->StartOffset(); + notification.mMouseButtonEventData.mCursorPos = + queryCharAtPointEvent.mRefPoint; + notification.mMouseButtonEventData.mCharRect = + queryCharAtPointEvent.mReply->mRect; + notification.mMouseButtonEventData.mButton = aMouseEvent.mButton; + notification.mMouseButtonEventData.mButtons = aMouseEvent.mButtons; + notification.mMouseButtonEventData.mModifiers = aMouseEvent.mModifiers; + + nsresult rv = IMEStateManager::NotifyIME(notification, mWidget); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + bool consumed = (rv == NS_SUCCESS_EVENT_CONSUMED); + if (consumed) { + aMouseEvent.PreventDefault(); + } + return consumed; +} + +void IMEContentObserver::CharacterDataWillChange( + nsIContent* aContent, const CharacterDataChangeInfo& aInfo) { + if (!aContent->IsText()) { + return; // Ignore if it's a comment node or something other invisible data + // node. + } + MOZ_ASSERT(mPreCharacterDataChangeLength < 0, + "CharacterDataChanged() should've reset " + "mPreCharacterDataChangeLength"); + + if (!NeedsTextChangeNotification() || + !nsContentUtils::IsInSameAnonymousTree(mRootElement, aContent)) { + return; + } + + mEndOfAddedTextCache.Clear(); + mStartOfRemovingTextRangeCache.Clear(); + + // Although we don't assume this change occurs while this is storing + // the range of added consecutive nodes, if it actually happens, we need to + // flush them since this change may occur before or in the range. So, it's + // safe to flush pending computation of mTextChangeData before handling this. + MaybeNotifyIMEOfAddedTextDuringDocumentChange(); + + mPreCharacterDataChangeLength = ContentEventHandler::GetNativeTextLength( + *aContent->AsText(), aInfo.mChangeStart, aInfo.mChangeEnd); + MOZ_ASSERT( + mPreCharacterDataChangeLength >= aInfo.mChangeEnd - aInfo.mChangeStart, + "The computed length must be same as or larger than XP length"); +} + +void IMEContentObserver::CharacterDataChanged( + nsIContent* aContent, const CharacterDataChangeInfo& aInfo) { + if (!aContent->IsText()) { + return; // Ignore if it's a comment node or something other invisible data + // node. + } + + // Let TextComposition have a change to update composition string range in + // the text node if the change is caused by the web apps. + if (mWidget && !IsEditorHandlingEventForComposition()) { + if (RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(mWidget)) { + composition->OnCharacterDataChanged(*aContent->AsText(), aInfo); + } + } + + if (!NeedsTextChangeNotification() || + !nsContentUtils::IsInSameAnonymousTree(mRootElement, aContent)) { + return; + } + + mEndOfAddedTextCache.Clear(); + mStartOfRemovingTextRangeCache.Clear(); + MOZ_ASSERT( + !HasAddedNodesDuringDocumentChange(), + "The stored range should be flushed before actually the data is changed"); + + int64_t removedLength = mPreCharacterDataChangeLength; + mPreCharacterDataChangeLength = -1; + + MOZ_ASSERT(removedLength >= 0, + "mPreCharacterDataChangeLength should've been set by " + "CharacterDataWillChange()"); + + uint32_t offset = 0; + // get offsets of change and fire notification + nsresult rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePosition(mRootElement, 0u), + NodePosition(aContent, aInfo.mChangeStart), mRootElement, &offset, + LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + uint32_t newLength = ContentEventHandler::GetNativeTextLength( + *aContent->AsText(), aInfo.mChangeStart, + aInfo.mChangeStart + aInfo.mReplaceLength); + + uint32_t oldEnd = offset + static_cast<uint32_t>(removedLength); + uint32_t newEnd = offset + newLength; + + TextChangeData data(offset, oldEnd, newEnd, + IsEditorHandlingEventForComposition(), + IsEditorComposing()); + MaybeNotifyIMEOfTextChange(data); +} + +void IMEContentObserver::NotifyContentAdded(nsINode* aContainer, + nsIContent* aFirstContent, + nsIContent* aLastContent) { + if (!NeedsTextChangeNotification() || + !nsContentUtils::IsInSameAnonymousTree(mRootElement, aFirstContent)) { + return; + } + + MOZ_ASSERT_IF(aFirstContent, aFirstContent->GetParentNode() == aContainer); + MOZ_ASSERT_IF(aLastContent, aLastContent->GetParentNode() == aContainer); + + mStartOfRemovingTextRangeCache.Clear(); + + // If it's in a document change, nodes are added consecutively. Therefore, + // if we cache the first node and the last node, we need to compute the + // range once. + // FYI: This is not true if the change caused by an operation in the editor. + if (IsInDocumentChange()) { + // Now, mEndOfAddedTextCache may be invalid if node is added before + // the last node in mEndOfAddedTextCache. Clear it. + mEndOfAddedTextCache.Clear(); + if (!HasAddedNodesDuringDocumentChange()) { + mFirstAddedContainer = mLastAddedContainer = aContainer; + mFirstAddedContent = aFirstContent; + mLastAddedContent = aLastContent; + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p NotifyContentAdded(), starts to store consecutive added " + "nodes", + this)); + return; + } + // If first node being added is not next node of the last node, + // notify IME of the previous range first, then, restart to cache the + // range. + if (NS_WARN_IF(!IsNextNodeOfLastAddedNode(aContainer, aFirstContent))) { + // Flush the old range first. + MaybeNotifyIMEOfAddedTextDuringDocumentChange(); + mFirstAddedContainer = aContainer; + mFirstAddedContent = aFirstContent; + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p NotifyContentAdded(), starts to store consecutive added " + "nodes", + this)); + } + mLastAddedContainer = aContainer; + mLastAddedContent = aLastContent; + return; + } + MOZ_ASSERT(!HasAddedNodesDuringDocumentChange(), + "The cache should be cleared when document change finished"); + + uint32_t offset = 0; + nsresult rv = NS_OK; + if (!mEndOfAddedTextCache.Match(aContainer, + aFirstContent->GetPreviousSibling())) { + mEndOfAddedTextCache.Clear(); + rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePosition(mRootElement, 0u), + NodePositionBefore(aContainer, PointBefore(aContainer, aFirstContent)), + mRootElement, &offset, LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED((rv)))) { + return; + } + } else { + offset = mEndOfAddedTextCache.mFlatTextLength; + } + + // get offset at the end of the last added node + uint32_t addingLength = 0; + rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePositionBefore(aContainer, PointBefore(aContainer, aFirstContent)), + NodePosition(aContainer, aLastContent), mRootElement, &addingLength, + LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED((rv)))) { + mEndOfAddedTextCache.Clear(); + return; + } + + // If multiple lines are being inserted in an HTML editor, next call of + // NotifyContentAdded() is for adding next node. Therefore, caching the text + // length can skip to compute the text length before the adding node and + // before of it. + mEndOfAddedTextCache.Cache(aContainer, aLastContent, offset + addingLength); + + if (!addingLength) { + return; + } + + TextChangeData data(offset, offset, offset + addingLength, + IsEditorHandlingEventForComposition(), + IsEditorComposing()); + MaybeNotifyIMEOfTextChange(data); +} + +void IMEContentObserver::ContentAppended(nsIContent* aFirstNewContent) { + nsIContent* parent = aFirstNewContent->GetParent(); + MOZ_ASSERT(parent); + NotifyContentAdded(parent, aFirstNewContent, parent->GetLastChild()); +} + +void IMEContentObserver::ContentInserted(nsIContent* aChild) { + MOZ_ASSERT(aChild); + NotifyContentAdded(aChild->GetParentNode(), aChild, aChild); +} + +void IMEContentObserver::ContentRemoved(nsIContent* aChild, + nsIContent* aPreviousSibling) { + if (!NeedsTextChangeNotification() || + !nsContentUtils::IsInSameAnonymousTree(mRootElement, aChild)) { + return; + } + + mEndOfAddedTextCache.Clear(); + MaybeNotifyIMEOfAddedTextDuringDocumentChange(); + + nsINode* containerNode = aChild->GetParentNode(); + MOZ_ASSERT(containerNode); + + uint32_t offset = 0; + nsresult rv = NS_OK; + if (!mStartOfRemovingTextRangeCache.Match(containerNode, aPreviousSibling)) { + // At removing a child node of aContainer, we need the line break caused + // by open tag of aContainer. Be careful when aPreviousSibling is nullptr. + + rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePosition(mRootElement, 0u), + NodePosition(containerNode, aPreviousSibling), mRootElement, &offset, + LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED(rv))) { + mStartOfRemovingTextRangeCache.Clear(); + return; + } + mStartOfRemovingTextRangeCache.Cache(containerNode, aPreviousSibling, + offset); + } else { + offset = mStartOfRemovingTextRangeCache.mFlatTextLength; + } + + // get offset at the end of the deleted node + uint32_t textLength = 0; + if (const Text* textNode = Text::FromNode(aChild)) { + textLength = ContentEventHandler::GetNativeTextLength(*textNode); + } else { + nsresult rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePositionBefore(aChild, 0u), + NodePosition(aChild, aChild->GetChildCount()), mRootElement, + &textLength, LINE_BREAK_TYPE_NATIVE, true); + if (NS_WARN_IF(NS_FAILED(rv))) { + mStartOfRemovingTextRangeCache.Clear(); + return; + } + } + + if (!textLength) { + return; + } + + TextChangeData data(offset, offset + textLength, offset, + IsEditorHandlingEventForComposition(), + IsEditorComposing()); + MaybeNotifyIMEOfTextChange(data); +} + +void IMEContentObserver::ClearAddedNodesDuringDocumentChange() { + mFirstAddedContainer = mLastAddedContainer = nullptr; + mFirstAddedContent = mLastAddedContent = nullptr; + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p ClearAddedNodesDuringDocumentChange(), finished storing " + "consecutive nodes", + this)); +} + +bool IMEContentObserver::IsNextNodeOfLastAddedNode(nsINode* aParent, + nsIContent* aChild) const { + MOZ_ASSERT(aParent); + MOZ_ASSERT(aChild && aChild->GetParentNode() == aParent); + MOZ_ASSERT(mRootElement); + MOZ_ASSERT(HasAddedNodesDuringDocumentChange()); + + // If the parent node isn't changed, we can check that mLastAddedContent has + // aChild as its next sibling. + if (aParent == mLastAddedContainer) { + if (NS_WARN_IF(mLastAddedContent->GetNextSibling() != aChild)) { + return false; + } + return true; + } + + // If the parent node is changed, that means that the recorded last added node + // shouldn't have a sibling. + if (NS_WARN_IF(mLastAddedContent->GetNextSibling())) { + return false; + } + + // If the node is aParent is a descendant of mLastAddedContainer, + // aChild should be the first child in the new container. + if (mLastAddedContainer == aParent->GetParent()) { + if (NS_WARN_IF(aChild->GetPreviousSibling())) { + return false; + } + return true; + } + + // Otherwise, we need to check it even with slow path. + nsIContent* nextContentOfLastAddedContent = + mLastAddedContent->GetNextNode(mRootElement->GetParentNode()); + if (NS_WARN_IF(!nextContentOfLastAddedContent)) { + return false; + } + if (NS_WARN_IF(nextContentOfLastAddedContent != aChild)) { + return false; + } + return true; +} + +void IMEContentObserver::MaybeNotifyIMEOfAddedTextDuringDocumentChange() { + if (!HasAddedNodesDuringDocumentChange()) { + return; + } + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p " + "IMEContentObserver::MaybeNotifyIMEOfAddedTextDuringDocumentChange()" + ", flushing stored consecutive nodes", + this)); + + // Notify IME of text change which is caused by added nodes now. + + // First, compute offset of start of first added node from start of the + // editor. + uint32_t offset; + nsresult rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePosition(mRootElement, 0u), + NodePosition(mFirstAddedContainer, + PointBefore(mFirstAddedContainer, mFirstAddedContent)), + mRootElement, &offset, LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED(rv))) { + ClearAddedNodesDuringDocumentChange(); + return; + } + + // Next, compute the text length of added nodes. + uint32_t length; + rv = ContentEventHandler::GetFlatTextLengthInRange( + NodePosition(mFirstAddedContainer, + PointBefore(mFirstAddedContainer, mFirstAddedContent)), + NodePosition(mLastAddedContainer, mLastAddedContent), mRootElement, + &length, LINE_BREAK_TYPE_NATIVE); + if (NS_WARN_IF(NS_FAILED(rv))) { + ClearAddedNodesDuringDocumentChange(); + return; + } + + // Finally, try to notify IME of the range. + TextChangeData data(offset, offset, offset + length, + IsEditorHandlingEventForComposition(), + IsEditorComposing()); + MaybeNotifyIMEOfTextChange(data); + ClearAddedNodesDuringDocumentChange(); +} + +void IMEContentObserver::OnTextControlValueChangedWhileNotObservable( + const nsAString& aNewValue) { + MOZ_ASSERT(mEditorBase); + MOZ_ASSERT(mEditorBase->IsTextEditor()); + uint32_t newLength = ContentEventHandler::GetNativeTextLength(aNewValue); + TextChangeData data(0, mTextControlValueLength, newLength, false, false); + MaybeNotifyIMEOfTextChange(data); +} + +void IMEContentObserver::BeginDocumentUpdate() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p BeginDocumentUpdate(), HasAddedNodesDuringDocumentChange()=%s", + this, ToChar(HasAddedNodesDuringDocumentChange()))); + + // If we're not in a nested document update, this will return early, + // otherwise, it will handle flusing any changes currently pending before + // entering a nested document update. + MaybeNotifyIMEOfAddedTextDuringDocumentChange(); +} + +void IMEContentObserver::EndDocumentUpdate() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p EndDocumentUpdate(), HasAddedNodesDuringDocumentChange()=%s", + this, ToChar(HasAddedNodesDuringDocumentChange()))); + + MaybeNotifyIMEOfAddedTextDuringDocumentChange(); +} + +void IMEContentObserver::SuppressNotifyingIME() { + mSuppressNotifications++; + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p SuppressNotifyingIME(), mSuppressNotifications=%u", this, + mSuppressNotifications)); +} + +void IMEContentObserver::UnsuppressNotifyingIME() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p UnsuppressNotifyingIME(), mSuppressNotifications=%u", this, + mSuppressNotifications)); + + if (!mSuppressNotifications || --mSuppressNotifications) { + return; + } + FlushMergeableNotifications(); +} + +void IMEContentObserver::OnEditActionHandled() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, ("0x%p EditAction()", this)); + + mEndOfAddedTextCache.Clear(); + mStartOfRemovingTextRangeCache.Clear(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::BeforeEditAction() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, ("0x%p BeforeEditAction()", this)); + + mEndOfAddedTextCache.Clear(); + mStartOfRemovingTextRangeCache.Clear(); +} + +void IMEContentObserver::CancelEditAction() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, ("0x%p CancelEditAction()", this)); + + mEndOfAddedTextCache.Clear(); + mStartOfRemovingTextRangeCache.Clear(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::PostFocusSetNotification() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p PostFocusSetNotification()", this)); + + mNeedsToNotifyIMEOfFocusSet = true; +} + +void IMEContentObserver::PostTextChangeNotification() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p PostTextChangeNotification(mTextChangeData=%s)", this, + ToString(mTextChangeData).c_str())); + + MOZ_ASSERT(mTextChangeData.IsValid(), + "mTextChangeData must have text change data"); + mNeedsToNotifyIMEOfTextChange = true; + // Even if the observer hasn't received selection change, selection in the + // flat text may have already been changed. For example, when previous `<p>` + // element of another `<p>` element which contains caret is removed by a DOM + // mutation, selection change event won't be fired, but selection start offset + // should be decreased by the length of removed `<p>` element. + // In such case, HandleQueryContentEvent shouldn't use the selection cache + // anymore. Therefore, we also need to post selection change notification + // too. eQuerySelectedText event may be dispatched at sending a text change + // notification. + mNeedsToNotifyIMEOfSelectionChange = true; +} + +void IMEContentObserver::PostSelectionChangeNotification() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p PostSelectionChangeNotification(), mSelectionData={ " + "mCausedByComposition=%s, mCausedBySelectionEvent=%s }", + this, ToChar(mSelectionData.mCausedByComposition), + ToChar(mSelectionData.mCausedBySelectionEvent))); + + mNeedsToNotifyIMEOfSelectionChange = true; +} + +void IMEContentObserver::MaybeNotifyIMEOfFocusSet() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p MaybeNotifyIMEOfFocusSet()", this)); + + PostFocusSetNotification(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::MaybeNotifyIMEOfTextChange( + const TextChangeDataBase& aTextChangeData) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p MaybeNotifyIMEOfTextChange(aTextChangeData=%s)", this, + ToString(aTextChangeData).c_str())); + + if (mEditorBase && mEditorBase->IsTextEditor()) { + MOZ_DIAGNOSTIC_ASSERT(static_cast<int64_t>(mTextControlValueLength) + + aTextChangeData.Difference() >= + 0); + mTextControlValueLength += aTextChangeData.Difference(); + } + + mTextChangeData += aTextChangeData; + PostTextChangeNotification(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::CancelNotifyingIMEOfTextChange() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p CancelNotifyingIMEOfTextChange()", this)); + mTextChangeData.Clear(); + mNeedsToNotifyIMEOfTextChange = false; +} + +void IMEContentObserver::MaybeNotifyIMEOfSelectionChange( + bool aCausedByComposition, bool aCausedBySelectionEvent, + bool aOccurredDuringComposition) { + MOZ_LOG( + sIMECOLog, LogLevel::Debug, + ("0x%p MaybeNotifyIMEOfSelectionChange(aCausedByComposition=%s, " + "aCausedBySelectionEvent=%s, aOccurredDuringComposition)", + this, ToChar(aCausedByComposition), ToChar(aCausedBySelectionEvent))); + + mSelectionData.AssignReason(aCausedByComposition, aCausedBySelectionEvent, + aOccurredDuringComposition); + PostSelectionChangeNotification(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::MaybeNotifyIMEOfPositionChange() { + MOZ_LOG(sIMECOLog, LogLevel::Verbose, + ("0x%p MaybeNotifyIMEOfPositionChange()", this)); + // If reflow is caused by ContentEventHandler during PositionChangeEvent + // sending NOTIFY_IME_OF_POSITION_CHANGE, we don't need to notify IME of it + // again since ContentEventHandler returns the result including this reflow's + // result. + if (mIsHandlingQueryContentEvent && + mSendingNotification == NOTIFY_IME_OF_POSITION_CHANGE) { + MOZ_LOG(sIMECOLog, LogLevel::Verbose, + ("0x%p MaybeNotifyIMEOfPositionChange(), ignored since caused by " + "ContentEventHandler during sending NOTIFY_IME_OF_POSITION_CHANGE", + this)); + return; + } + PostPositionChangeNotification(); + FlushMergeableNotifications(); +} + +void IMEContentObserver::CancelNotifyingIMEOfPositionChange() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p CancelNotifyIMEOfPositionChange()", this)); + mNeedsToNotifyIMEOfPositionChange = false; +} + +void IMEContentObserver::MaybeNotifyCompositionEventHandled() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p MaybeNotifyCompositionEventHandled()", this)); + + PostCompositionEventHandledNotification(); + FlushMergeableNotifications(); +} + +bool IMEContentObserver::UpdateSelectionCache(bool aRequireFlush /* = true */) { + MOZ_ASSERT(IsSafeToNotifyIME()); + + mSelectionData.ClearSelectionData(); + + // XXX Cannot we cache some information for reducing the cost to compute + // selection offset and writing mode? + WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText, + mWidget); + querySelectedTextEvent.mNeedsToFlushLayout = aRequireFlush; + ContentEventHandler handler(GetPresContext()); + handler.OnQuerySelectedText(&querySelectedTextEvent); + if (NS_WARN_IF(querySelectedTextEvent.Failed()) || + NS_WARN_IF(querySelectedTextEvent.mReply->mContentsRoot != + mRootElement)) { + return false; + } + + mFocusedWidget = querySelectedTextEvent.mReply->mFocusedWidget; + mSelectionData.Assign(querySelectedTextEvent); + + // WARNING: Don't set the reason of selection change here because it should be + // set the reason at sending the notification. + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p UpdateSelectionCache(), mSelectionData=%s", this, + ToString(mSelectionData).c_str())); + + return true; +} + +void IMEContentObserver::PostPositionChangeNotification() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p PostPositionChangeNotification()", this)); + + mNeedsToNotifyIMEOfPositionChange = true; +} + +void IMEContentObserver::PostCompositionEventHandledNotification() { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p PostCompositionEventHandledNotification()", this)); + + mNeedsToNotifyIMEOfCompositionEventHandled = true; +} + +bool IMEContentObserver::IsReflowLocked() const { + nsPresContext* presContext = GetPresContext(); + if (NS_WARN_IF(!presContext)) { + return false; + } + PresShell* presShell = presContext->GetPresShell(); + if (NS_WARN_IF(!presShell)) { + return false; + } + // During reflow, we shouldn't notify IME because IME may query content + // synchronously. Then, it causes ContentEventHandler will try to flush + // pending notifications during reflow. + return presShell->IsReflowLocked(); +} + +bool IMEContentObserver::IsSafeToNotifyIME() const { + // If this is already detached from the widget, this doesn't need to notify + // anything. + if (!mWidget) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IsSafeToNotifyIME(), it's not safe because of no widget", + this)); + return false; + } + + // Don't notify IME of anything if it's not good time to do it. + if (mSuppressNotifications) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IsSafeToNotifyIME(), it's not safe because of no widget", + this)); + return false; + } + + if (!mESM || NS_WARN_IF(!GetPresContext())) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IsSafeToNotifyIME(), it's not safe because of no " + "EventStateManager and/or PresContext", + this)); + return false; + } + + // If it's in reflow, we should wait to finish the reflow. + // FYI: This should be called again from Reflow() or ReflowInterruptible(). + if (IsReflowLocked()) { + MOZ_LOG( + sIMECOLog, LogLevel::Debug, + ("0x%p IsSafeToNotifyIME(), it's not safe because of reflow locked", + this)); + return false; + } + + // If we're in handling an edit action, this method will be called later. + if (mEditorBase && mEditorBase->IsInEditSubAction()) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IsSafeToNotifyIME(), it's not safe because of focused " + "editor handling somethings", + this)); + return false; + } + + return true; +} + +void IMEContentObserver::FlushMergeableNotifications() { + if (!IsSafeToNotifyIME()) { + // So, if this is already called, this should do nothing. + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p FlushMergeableNotifications(), Warning, do nothing due to " + "unsafe to notify IME", + this)); + return; + } + + // Notifying something may cause nested call of this method. For example, + // when somebody notified one of the notifications may dispatch query content + // event. Then, it causes flushing layout which may cause another layout + // change notification. + + if (mQueuedSender) { + // So, if this is already called, this should do nothing. + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p FlushMergeableNotifications(), Warning, do nothing due to " + "already flushing pending notifications", + this)); + return; + } + + // If text change notification and/or position change notification becomes + // unnecessary, let's cancel them. + if (mNeedsToNotifyIMEOfTextChange && !NeedsTextChangeNotification()) { + CancelNotifyingIMEOfTextChange(); + } + if (mNeedsToNotifyIMEOfPositionChange && !NeedsPositionChangeNotification()) { + CancelNotifyingIMEOfPositionChange(); + } + + if (!NeedsToNotifyIMEOfSomething()) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p FlushMergeableNotifications(), Warning, due to no pending " + "notifications", + this)); + return; + } + + // NOTE: Reset each pending flag because sending notification may cause + // another change. + + MOZ_LOG( + sIMECOLog, LogLevel::Info, + ("0x%p FlushMergeableNotifications(), creating IMENotificationSender...", + this)); + + // If contents in selection range is modified, the selection range still + // has removed node from the tree. In such case, ContentIterator won't + // work well. Therefore, we shouldn't use AddScriptRunnder() here since + // it may kick runnable event immediately after DOM tree is changed but + // the selection range isn't modified yet. + mQueuedSender = new IMENotificationSender(this); + mQueuedSender->Dispatch(mDocShell); + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p FlushMergeableNotifications(), finished", this)); +} + +void IMEContentObserver::TryToFlushPendingNotifications(bool aAllowAsync) { + // If a sender instance is sending notifications, we shouldn't try to create + // a new sender again because the sender will recreate by itself if there are + // new pending notifications. + if (mSendingNotification != NOTIFY_IME_OF_NOTHING) { + return; + } + + // When the caller allows to put off notifying IME, we can wait the next + // call of this method or to run the queued sender. + if (mQueuedSender && XRE_IsContentProcess() && aAllowAsync) { + return; + } + + if (!mQueuedSender) { + // If it was not safe to dispatch notifications when the pending + // notifications are posted, this may not have IMENotificationSender + // instance because it couldn't dispatch it, e.g., when an edit sub-action + // is being handled in the editor, we shouldn't do it even if it's safe to + // run script. Therefore, we need to create the sender instance here in the + // case. + if (!NeedsToNotifyIMEOfSomething()) { + return; + } + mQueuedSender = new IMENotificationSender(this); + } + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p TryToFlushPendingNotifications(), performing queued " + "IMENotificationSender forcibly", + this)); + RefPtr<IMENotificationSender> queuedSender = mQueuedSender; + queuedSender->Run(); +} + +/****************************************************************************** + * mozilla::IMEContentObserver::AChangeEvent + ******************************************************************************/ + +bool IMEContentObserver::AChangeEvent::CanNotifyIME( + ChangeEventType aChangeEventType) const { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (NS_WARN_IF(!observer)) { + return false; + } + + const LogLevel debugOrVerbose = + aChangeEventType == ChangeEventType::eChangeEventType_Position + ? LogLevel::Verbose + : LogLevel::Debug; + + if (aChangeEventType == eChangeEventType_CompositionEventHandled) { + if (observer->mWidget) { + return true; + } + MOZ_LOG(sIMECOLog, debugOrVerbose, + ("0x%p AChangeEvent::CanNotifyIME(), Cannot notify IME of " + "composition event handled because of no widget", + this)); + return false; + } + State state = observer->GetState(); + // If it's not initialized, we should do nothing. + if (state == eState_NotObserving) { + MOZ_LOG(sIMECOLog, debugOrVerbose, + ("0x%p AChangeEvent::CanNotifyIME(), Cannot notify IME because " + "of not observing", + this)); + return false; + } + // If setting focus, just check the state. + if (aChangeEventType == eChangeEventType_Focus) { + if (!observer->mIMEHasFocus) { + return true; + } + MOZ_LOG(sIMECOLog, debugOrVerbose, + ("0x%p AChangeEvent::CanNotifyIME(), Cannot notify IME of focus " + "change because of already focused", + this)); + NS_WARNING("IME already has focus"); + return false; + } + // If we've not notified IME of focus yet, we shouldn't notify anything. + if (!observer->mIMEHasFocus) { + MOZ_LOG(sIMECOLog, debugOrVerbose, + ("0x%p AChangeEvent::CanNotifyIME(), Cannot notify IME because " + "of not focused", + this)); + return false; + } + + // If IME has focus, IMEContentObserver must hold the widget. + MOZ_ASSERT(observer->mWidget); + + return true; +} + +bool IMEContentObserver::AChangeEvent::IsSafeToNotifyIME( + ChangeEventType aChangeEventType) const { + const LogLevel warningOrVerbose = + aChangeEventType == ChangeEventType::eChangeEventType_Position + ? LogLevel::Verbose + : LogLevel::Warning; + + if (NS_WARN_IF(!nsContentUtils::IsSafeToRunScript())) { + MOZ_LOG(sIMECOLog, warningOrVerbose, + ("0x%p AChangeEvent::IsSafeToNotifyIME(), Warning, Cannot notify " + "IME because of not safe to run script", + this)); + return false; + } + + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + MOZ_LOG(sIMECOLog, warningOrVerbose, + ("0x%p AChangeEvent::IsSafeToNotifyIME(), Warning, Cannot notify " + "IME because of no observer", + this)); + return false; + } + + // While we're sending a notification, we shouldn't send another notification + // recursively. + if (observer->mSendingNotification != NOTIFY_IME_OF_NOTHING) { + MOZ_LOG(sIMECOLog, warningOrVerbose, + ("0x%p AChangeEvent::IsSafeToNotifyIME(), Warning, Cannot notify " + "IME because of the observer sending another notification", + this)); + return false; + } + State state = observer->GetState(); + if (aChangeEventType == eChangeEventType_Focus) { + if (NS_WARN_IF(state != eState_Initializing && state != eState_Observing)) { + MOZ_LOG(sIMECOLog, warningOrVerbose, + ("0x%p AChangeEvent::IsSafeToNotifyIME(), Warning, Cannot " + "notify IME of focus because of not observing", + this)); + return false; + } + } else if (aChangeEventType == eChangeEventType_CompositionEventHandled) { + // It doesn't need to check the observing status. + } else if (state != eState_Observing) { + MOZ_LOG(sIMECOLog, warningOrVerbose, + ("0x%p AChangeEvent::IsSafeToNotifyIME(), Warning, Cannot notify " + "IME because of not observing", + this)); + return false; + } + return observer->IsSafeToNotifyIME(); +} + +/****************************************************************************** + * mozilla::IMEContentObserver::IMENotificationSender + ******************************************************************************/ + +void IMEContentObserver::IMENotificationSender::Dispatch( + nsIDocShell* aDocShell) { + if (XRE_IsContentProcess() && aDocShell) { + RefPtr<nsPresContext> presContext = aDocShell->GetPresContext(); + if (presContext) { + nsRefreshDriver* refreshDriver = presContext->RefreshDriver(); + if (refreshDriver) { + refreshDriver->AddEarlyRunner(this); + return; + } + } + } + + nsIScriptGlobalObject* globalObject = + aDocShell ? aDocShell->GetScriptGlobalObject() : nullptr; + if (globalObject) { + RefPtr<IMENotificationSender> queuedSender = this; + globalObject->Dispatch(TaskCategory::Other, queuedSender.forget()); + } else { + NS_DispatchToCurrentThread(this); + } +} + +NS_IMETHODIMP +IMEContentObserver::IMENotificationSender::Run() { + if (NS_WARN_IF(mIsRunning)) { + MOZ_LOG( + sIMECOLog, LogLevel::Error, + ("0x%p IMENotificationSender::Run(), FAILED, due to called recursively", + this)); + return NS_OK; + } + + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return NS_OK; + } + + AutoRestore<bool> running(mIsRunning); + mIsRunning = true; + + // This instance was already performed forcibly. + if (observer->mQueuedSender != this) { + return NS_OK; + } + + // NOTE: Reset each pending flag because sending notification may cause + // another change. + + if (observer->mNeedsToNotifyIMEOfFocusSet) { + observer->mNeedsToNotifyIMEOfFocusSet = false; + SendFocusSet(); + observer->mQueuedSender = nullptr; + // If it's not safe to notify IME of focus, SendFocusSet() sets + // mNeedsToNotifyIMEOfFocusSet true again. For guaranteeing to send the + // focus notification later, we should put a new sender into the queue but + // this case must be rare. Note that if mIMEContentObserver is already + // destroyed, mNeedsToNotifyIMEOfFocusSet is never set true again. + if (observer->mNeedsToNotifyIMEOfFocusSet) { + MOZ_ASSERT(!observer->mIMEHasFocus); + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::Run(), posting " + "IMENotificationSender to current thread", + this)); + observer->mQueuedSender = new IMENotificationSender(observer); + observer->mQueuedSender->Dispatch(observer->mDocShell); + return NS_OK; + } + // This is the first notification to IME. So, we don't need to notify + // anymore since IME starts to query content after it gets focus. + observer->ClearPendingNotifications(); + return NS_OK; + } + + if (observer->mNeedsToNotifyIMEOfTextChange) { + observer->mNeedsToNotifyIMEOfTextChange = false; + SendTextChange(); + } + + // If a text change notification causes another text change again, we should + // notify IME of that before sending a selection change notification. + if (!observer->mNeedsToNotifyIMEOfTextChange) { + // Be aware, PuppetWidget depends on the order of this. A selection change + // notification should not be sent before a text change notification because + // PuppetWidget shouldn't query new text content every selection change. + if (observer->mNeedsToNotifyIMEOfSelectionChange) { + observer->mNeedsToNotifyIMEOfSelectionChange = false; + SendSelectionChange(); + } + } + + // If a text change notification causes another text change again or a + // selection change notification causes either a text change or another + // selection change, we should notify IME of those before sending a position + // change notification. + if (!observer->mNeedsToNotifyIMEOfTextChange && + !observer->mNeedsToNotifyIMEOfSelectionChange) { + if (observer->mNeedsToNotifyIMEOfPositionChange) { + observer->mNeedsToNotifyIMEOfPositionChange = false; + SendPositionChange(); + } + } + + // Composition event handled notification should be sent after all the + // other notifications because this notifies widget of finishing all pending + // events are handled completely. + if (!observer->mNeedsToNotifyIMEOfTextChange && + !observer->mNeedsToNotifyIMEOfSelectionChange && + !observer->mNeedsToNotifyIMEOfPositionChange) { + if (observer->mNeedsToNotifyIMEOfCompositionEventHandled) { + observer->mNeedsToNotifyIMEOfCompositionEventHandled = false; + SendCompositionEventHandled(); + } + } + + observer->mQueuedSender = nullptr; + + // If notifications caused some new change, we should notify them now. + if (observer->NeedsToNotifyIMEOfSomething()) { + if (observer->GetState() == eState_StoppedObserving) { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::Run(), waiting " + "IMENotificationSender to be reinitialized", + this)); + } else { + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::Run(), posting " + "IMENotificationSender to current thread", + this)); + observer->mQueuedSender = new IMENotificationSender(observer); + observer->mQueuedSender->Dispatch(observer->mDocShell); + } + } + return NS_OK; +} + +void IMEContentObserver::IMENotificationSender::SendFocusSet() { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return; + } + + if (!CanNotifyIME(eChangeEventType_Focus)) { + // If IMEContentObserver has already gone, we don't need to notify IME of + // focus. + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendFocusSet(), Warning, does not " + "send notification due to impossible to notify IME of focus", + this)); + observer->ClearPendingNotifications(); + return; + } + + if (!IsSafeToNotifyIME(eChangeEventType_Focus)) { + MOZ_LOG( + sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendFocusSet(), Warning, does not send " + "notification due to unsafe, retrying to send NOTIFY_IME_OF_FOCUS...", + this)); + observer->PostFocusSetNotification(); + return; + } + + observer->mIMEHasFocus = true; + // Initialize selection cache with the first selection data. +#ifdef XP_MACOSX + // We need to flush layout only on macOS because character coordinates are + // cached by cocoa with this call, but we don't have a way to update them + // after that. Therefore, we need the latest layout information right now. + observer->UpdateSelectionCache(true); +#else + // We avoid flushing for focus in the general case. + observer->UpdateSelectionCache(false); +#endif // #ifdef XP_MACOSX #else + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p IMENotificationSender::SendFocusSet(), sending " + "NOTIFY_IME_OF_FOCUS...", + this)); + + MOZ_RELEASE_ASSERT(observer->mSendingNotification == NOTIFY_IME_OF_NOTHING); + observer->mSendingNotification = NOTIFY_IME_OF_FOCUS; + IMEStateManager::NotifyIME(IMENotification(NOTIFY_IME_OF_FOCUS), + observer->mWidget); + observer->mSendingNotification = NOTIFY_IME_OF_NOTHING; + + // IMENotificationRequests referred by ObserveEditableNode() may be different + // before or after widget receives NOTIFY_IME_OF_FOCUS. Therefore, we need + // to guarantee to call ObserveEditableNode() after sending + // NOTIFY_IME_OF_FOCUS. + observer->OnIMEReceivedFocus(); + + MOZ_LOG( + sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendFocusSet(), sent NOTIFY_IME_OF_FOCUS", + this)); +} + +void IMEContentObserver::IMENotificationSender::SendSelectionChange() { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return; + } + + if (!CanNotifyIME(eChangeEventType_Selection)) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendSelectionChange(), Warning, " + "does not send notification due to impossible to notify IME of " + "selection change", + this)); + return; + } + + if (!IsSafeToNotifyIME(eChangeEventType_Selection)) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendSelectionChange(), Warning, " + "does not send notification due to unsafe, retrying to send " + "NOTIFY_IME_OF_SELECTION_CHANGE...", + this)); + observer->PostSelectionChangeNotification(); + return; + } + + SelectionChangeData lastSelChangeData = observer->mSelectionData; + if (NS_WARN_IF(!observer->UpdateSelectionCache())) { + MOZ_LOG(sIMECOLog, LogLevel::Error, + ("0x%p IMENotificationSender::SendSelectionChange(), FAILED, due " + "to UpdateSelectionCache() failure", + this)); + return; + } + + // The state may be changed since querying content causes flushing layout. + if (!CanNotifyIME(eChangeEventType_Selection)) { + MOZ_LOG(sIMECOLog, LogLevel::Error, + ("0x%p IMENotificationSender::SendSelectionChange(), FAILED, due " + "to flushing layout having changed something", + this)); + return; + } + + // If the selection isn't changed actually, we shouldn't notify IME of + // selection change. + SelectionChangeData& newSelChangeData = observer->mSelectionData; + if (lastSelChangeData.IsInitialized() && + lastSelChangeData.EqualsRangeAndDirectionAndWritingMode( + newSelChangeData)) { + MOZ_LOG( + sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendSelectionChange(), not notifying IME " + "of NOTIFY_IME_OF_SELECTION_CHANGE due to not changed actually", + this)); + return; + } + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p IMENotificationSender::SendSelectionChange(), sending " + "NOTIFY_IME_OF_SELECTION_CHANGE... newSelChangeData=%s", + this, ToString(newSelChangeData).c_str())); + + IMENotification notification(NOTIFY_IME_OF_SELECTION_CHANGE); + notification.SetData(observer->mSelectionData); + + MOZ_RELEASE_ASSERT(observer->mSendingNotification == NOTIFY_IME_OF_NOTHING); + observer->mSendingNotification = NOTIFY_IME_OF_SELECTION_CHANGE; + IMEStateManager::NotifyIME(notification, observer->mWidget); + observer->mSendingNotification = NOTIFY_IME_OF_NOTHING; + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendSelectionChange(), sent " + "NOTIFY_IME_OF_SELECTION_CHANGE", + this)); +} + +void IMEContentObserver::IMENotificationSender::SendTextChange() { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return; + } + + if (!CanNotifyIME(eChangeEventType_Text)) { + MOZ_LOG( + sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendTextChange(), Warning, does not " + "send notification due to impossible to notify IME of text change", + this)); + return; + } + + if (!IsSafeToNotifyIME(eChangeEventType_Text)) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendTextChange(), Warning, does " + "not send notification due to unsafe, retrying to send " + "NOTIFY_IME_OF_TEXT_CHANGE...", + this)); + observer->PostTextChangeNotification(); + return; + } + + // If text change notification is unnecessary anymore, just cancel it. + if (!observer->NeedsTextChangeNotification()) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendTextChange(), Warning, " + "canceling sending NOTIFY_IME_OF_TEXT_CHANGE", + this)); + observer->CancelNotifyingIMEOfTextChange(); + return; + } + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p IMENotificationSender::SendTextChange(), sending " + "NOTIFY_IME_OF_TEXT_CHANGE... mIMEContentObserver={ " + "mTextChangeData=%s }", + this, ToString(observer->mTextChangeData).c_str())); + + IMENotification notification(NOTIFY_IME_OF_TEXT_CHANGE); + notification.SetData(observer->mTextChangeData); + observer->mTextChangeData.Clear(); + + MOZ_RELEASE_ASSERT(observer->mSendingNotification == NOTIFY_IME_OF_NOTHING); + observer->mSendingNotification = NOTIFY_IME_OF_TEXT_CHANGE; + IMEStateManager::NotifyIME(notification, observer->mWidget); + observer->mSendingNotification = NOTIFY_IME_OF_NOTHING; + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendTextChange(), sent " + "NOTIFY_IME_OF_TEXT_CHANGE", + this)); +} + +void IMEContentObserver::IMENotificationSender::SendPositionChange() { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return; + } + + if (!CanNotifyIME(eChangeEventType_Position)) { + MOZ_LOG(sIMECOLog, LogLevel::Verbose, + ("0x%p IMENotificationSender::SendPositionChange(), Warning, " + "does not send notification due to impossible to notify IME of " + "position change", + this)); + return; + } + + if (!IsSafeToNotifyIME(eChangeEventType_Position)) { + MOZ_LOG(sIMECOLog, LogLevel::Verbose, + ("0x%p IMENotificationSender::SendPositionChange(), Warning, " + "does not send notification due to unsafe, retrying to send " + "NOTIFY_IME_OF_POSITION_CHANGE...", + this)); + observer->PostPositionChangeNotification(); + return; + } + + // If position change notification is unnecessary anymore, just cancel it. + if (!observer->NeedsPositionChangeNotification()) { + MOZ_LOG(sIMECOLog, LogLevel::Verbose, + ("0x%p IMENotificationSender::SendPositionChange(), Warning, " + "canceling sending NOTIFY_IME_OF_POSITION_CHANGE", + this)); + observer->CancelNotifyingIMEOfPositionChange(); + return; + } + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p IMENotificationSender::SendPositionChange(), sending " + "NOTIFY_IME_OF_POSITION_CHANGE...", + this)); + + MOZ_RELEASE_ASSERT(observer->mSendingNotification == NOTIFY_IME_OF_NOTHING); + observer->mSendingNotification = NOTIFY_IME_OF_POSITION_CHANGE; + IMEStateManager::NotifyIME(IMENotification(NOTIFY_IME_OF_POSITION_CHANGE), + observer->mWidget); + observer->mSendingNotification = NOTIFY_IME_OF_NOTHING; + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendPositionChange(), sent " + "NOTIFY_IME_OF_POSITION_CHANGE", + this)); +} + +void IMEContentObserver::IMENotificationSender::SendCompositionEventHandled() { + RefPtr<IMEContentObserver> observer = GetObserver(); + if (!observer) { + return; + } + + if (!CanNotifyIME(eChangeEventType_CompositionEventHandled)) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendCompositionEventHandled(), " + "Warning, does not send notification due to impossible to notify " + "IME of composition event handled", + this)); + return; + } + + if (!IsSafeToNotifyIME(eChangeEventType_CompositionEventHandled)) { + MOZ_LOG(sIMECOLog, LogLevel::Warning, + ("0x%p IMENotificationSender::SendCompositionEventHandled(), " + "Warning, does not send notification due to unsafe, retrying to " + "send NOTIFY_IME_OF_POSITION_CHANGE...", + this)); + observer->PostCompositionEventHandledNotification(); + return; + } + + MOZ_LOG(sIMECOLog, LogLevel::Info, + ("0x%p IMENotificationSender::SendCompositionEventHandled(), sending " + "NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED...", + this)); + + MOZ_RELEASE_ASSERT(observer->mSendingNotification == NOTIFY_IME_OF_NOTHING); + observer->mSendingNotification = NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED; + IMEStateManager::NotifyIME( + IMENotification(NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED), + observer->mWidget); + observer->mSendingNotification = NOTIFY_IME_OF_NOTHING; + + MOZ_LOG(sIMECOLog, LogLevel::Debug, + ("0x%p IMENotificationSender::SendCompositionEventHandled(), sent " + "NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED", + this)); +} + +/****************************************************************************** + * mozilla::IMEContentObserver::DocumentObservingHelper + ******************************************************************************/ + +NS_IMPL_CYCLE_COLLECTION_CLASS(IMEContentObserver::DocumentObserver) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(IMEContentObserver::DocumentObserver) + // StopObserving() releases mIMEContentObserver and mDocument. + tmp->StopObserving(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IMEContentObserver::DocumentObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIMEContentObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IMEContentObserver::DocumentObserver) + NS_INTERFACE_MAP_ENTRY(nsIDocumentObserver) + NS_INTERFACE_MAP_ENTRY(nsIMutationObserver) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(IMEContentObserver::DocumentObserver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(IMEContentObserver::DocumentObserver) + +void IMEContentObserver::DocumentObserver::Observe(Document* aDocument) { + MOZ_ASSERT(aDocument); + + // Guarantee that aDocument won't be destroyed during a call of + // StopObserving(). + RefPtr<Document> newDocument = aDocument; + + StopObserving(); + + mDocument = std::move(newDocument); + mDocument->AddObserver(this); +} + +void IMEContentObserver::DocumentObserver::StopObserving() { + if (!IsObserving()) { + return; + } + + // Grab IMEContentObserver which could be destroyed during method calls. + RefPtr<IMEContentObserver> observer = std::move(mIMEContentObserver); + + // Stop observing the document first. + RefPtr<Document> document = std::move(mDocument); + document->RemoveObserver(this); + + // Notify IMEContentObserver of ending of document updates if this already + // notified it of beginning of document updates. + for (; IsUpdating(); --mDocumentUpdating) { + // FYI: IsUpdating() returns true until mDocumentUpdating becomes 0. + // However, IsObserving() returns false now because mDocument was + // already cleared above. Therefore, this method won't be called + // recursively. + observer->EndDocumentUpdate(); + } +} + +void IMEContentObserver::DocumentObserver::Destroy() { + StopObserving(); + mIMEContentObserver = nullptr; +} + +void IMEContentObserver::DocumentObserver::BeginUpdate(Document* aDocument) { + if (NS_WARN_IF(Destroyed()) || NS_WARN_IF(!IsObserving())) { + return; + } + mDocumentUpdating++; + mIMEContentObserver->BeginDocumentUpdate(); +} + +void IMEContentObserver::DocumentObserver::EndUpdate(Document* aDocument) { + if (NS_WARN_IF(Destroyed()) || NS_WARN_IF(!IsObserving()) || + NS_WARN_IF(!IsUpdating())) { + return; + } + mDocumentUpdating--; + mIMEContentObserver->EndDocumentUpdate(); +} + +} // namespace mozilla |