summaryrefslogtreecommitdiffstats
path: root/widget/ContentCache.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /widget/ContentCache.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'widget/ContentCache.h')
-rw-r--r--widget/ContentCache.h574
1 files changed, 574 insertions, 0 deletions
diff --git a/widget/ContentCache.h b/widget/ContentCache.h
new file mode 100644
index 0000000000..3f74002d26
--- /dev/null
+++ b/widget/ContentCache.h
@@ -0,0 +1,574 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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/. */
+
+#ifndef mozilla_ContentCache_h
+#define mozilla_ContentCache_h
+
+#include <stdint.h>
+
+#include "mozilla/widget/IMEData.h"
+#include "mozilla/ipc/IPCForwards.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ToString.h"
+#include "mozilla/WritingModes.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "Units.h"
+
+class nsIWidget;
+
+namespace mozilla {
+
+class ContentCacheInParent;
+
+namespace dom {
+class BrowserParent;
+} // namespace dom
+
+/**
+ * ContentCache stores various information of the child content.
+ * This class has members which are necessary both in parent process and
+ * content process.
+ */
+
+class ContentCache {
+ public:
+ typedef CopyableTArray<LayoutDeviceIntRect> RectArray;
+ typedef widget::IMENotification IMENotification;
+
+ ContentCache() = default;
+
+ [[nodiscard]] bool IsValid() const;
+
+ protected:
+ // Whole text in the target
+ Maybe<nsString> mText;
+
+ // Start offset of the composition string.
+ Maybe<uint32_t> mCompositionStart;
+
+ enum { ePrevCharRect = 1, eNextCharRect = 0 };
+
+ struct Selection final {
+ // Following values are offset in "flat text".
+ uint32_t mAnchor;
+ uint32_t mFocus;
+
+ WritingMode mWritingMode;
+
+ bool mHasRange;
+
+ // Character rects at previous and next character of mAnchor and mFocus.
+ // The reason why ContentCache needs to store each previous character of
+ // them is IME may query character rect of the last character of a line
+ // when caret is at the end of the line.
+ // Note that use ePrevCharRect and eNextCharRect for accessing each item.
+ LayoutDeviceIntRect mAnchorCharRects[2];
+ LayoutDeviceIntRect mFocusCharRects[2];
+
+ // Whole rect of selected text. This is empty if the selection is collapsed.
+ LayoutDeviceIntRect mRect;
+
+ Selection() : mAnchor(UINT32_MAX), mFocus(UINT32_MAX), mHasRange(false) {
+ ClearRects();
+ };
+
+ explicit Selection(
+ const IMENotification::SelectionChangeDataBase& aSelectionChangeData)
+ : mAnchor(UINT32_MAX),
+ mFocus(UINT32_MAX),
+ mWritingMode(aSelectionChangeData.GetWritingMode()),
+ mHasRange(aSelectionChangeData.HasRange()) {
+ if (mHasRange) {
+ mAnchor = aSelectionChangeData.AnchorOffset();
+ mFocus = aSelectionChangeData.FocusOffset();
+ }
+ }
+
+ [[nodiscard]] bool IsValidIn(const nsAString& aText) const {
+ return !mHasRange ||
+ (mAnchor <= aText.Length() && mFocus <= aText.Length());
+ }
+
+ explicit Selection(const WidgetQueryContentEvent& aQuerySelectedTextEvent);
+
+ void ClearRects() {
+ for (auto& rect : mAnchorCharRects) {
+ rect.SetEmpty();
+ }
+ for (auto& rect : mFocusCharRects) {
+ rect.SetEmpty();
+ }
+ mRect.SetEmpty();
+ }
+ bool HasRects() const {
+ for (auto& rect : mAnchorCharRects) {
+ if (!rect.IsEmpty()) {
+ return true;
+ }
+ }
+ for (auto& rect : mFocusCharRects) {
+ if (!rect.IsEmpty()) {
+ return true;
+ }
+ }
+ return !mRect.IsEmpty();
+ }
+
+ bool IsCollapsed() const { return !mHasRange || mFocus == mAnchor; }
+ bool Reversed() const {
+ MOZ_ASSERT(mHasRange);
+ return mFocus < mAnchor;
+ }
+ uint32_t StartOffset() const {
+ MOZ_ASSERT(mHasRange);
+ return Reversed() ? mFocus : mAnchor;
+ }
+ uint32_t EndOffset() const {
+ MOZ_ASSERT(mHasRange);
+ return Reversed() ? mAnchor : mFocus;
+ }
+ uint32_t Length() const {
+ MOZ_ASSERT(mHasRange);
+ return Reversed() ? mAnchor - mFocus : mFocus - mAnchor;
+ }
+ LayoutDeviceIntRect StartCharRect() const {
+ return Reversed() ? mFocusCharRects[eNextCharRect]
+ : mAnchorCharRects[eNextCharRect];
+ }
+ LayoutDeviceIntRect EndCharRect() const {
+ return Reversed() ? mAnchorCharRects[eNextCharRect]
+ : mFocusCharRects[eNextCharRect];
+ }
+
+ friend std::ostream& operator<<(std::ostream& aStream,
+ const Selection& aSelection) {
+ aStream << "{ ";
+ if (!aSelection.mHasRange) {
+ aStream << "HasRange()=false";
+ } else {
+ aStream << "mAnchor=" << aSelection.mAnchor
+ << ", mFocus=" << aSelection.mFocus << ", mWritingMode="
+ << ToString(aSelection.mWritingMode).c_str();
+ }
+ if (aSelection.HasRects()) {
+ if (aSelection.mAnchor > 0) {
+ aStream << ", mAnchorCharRects[ePrevCharRect]="
+ << aSelection.mAnchorCharRects[ContentCache::ePrevCharRect];
+ }
+ aStream << ", mAnchorCharRects[eNextCharRect]="
+ << aSelection.mAnchorCharRects[ContentCache::eNextCharRect];
+ if (aSelection.mFocus > 0) {
+ aStream << ", mFocusCharRects[ePrevCharRect]="
+ << aSelection.mFocusCharRects[ContentCache::ePrevCharRect];
+ }
+ aStream << ", mFocusCharRects[eNextCharRect]="
+ << aSelection.mFocusCharRects[ContentCache::eNextCharRect]
+ << ", mRect=" << aSelection.mRect;
+ }
+ if (aSelection.mHasRange) {
+ aStream << ", Reversed()=" << (aSelection.Reversed() ? "true" : "false")
+ << ", StartOffset()=" << aSelection.StartOffset()
+ << ", EndOffset()=" << aSelection.EndOffset()
+ << ", IsCollapsed()="
+ << (aSelection.IsCollapsed() ? "true" : "false")
+ << ", Length()=" << aSelection.Length();
+ }
+ aStream << " }";
+ return aStream;
+ }
+ };
+ Maybe<Selection> mSelection;
+
+ // Stores first char rect because Yosemite's Japanese IME sometimes tries
+ // to query it. If there is no text, this is caret rect.
+ LayoutDeviceIntRect mFirstCharRect;
+
+ struct Caret final {
+ uint32_t mOffset;
+ LayoutDeviceIntRect mRect;
+
+ explicit Caret(uint32_t aOffset, LayoutDeviceIntRect aCaretRect)
+ : mOffset(aOffset), mRect(aCaretRect) {}
+
+ uint32_t Offset() const { return mOffset; }
+ bool HasRect() const { return !mRect.IsEmpty(); }
+
+ [[nodiscard]] bool IsValidIn(const nsAString& aText) const {
+ return mOffset <= aText.Length();
+ }
+
+ friend std::ostream& operator<<(std::ostream& aStream,
+ const Caret& aCaret) {
+ aStream << "{ mOffset=" << aCaret.mOffset;
+ if (aCaret.HasRect()) {
+ aStream << ", mRect=" << aCaret.mRect;
+ }
+ return aStream << " }";
+ }
+
+ private:
+ Caret() = default;
+
+ friend struct IPC::ParamTraits<ContentCache::Caret>;
+ ALLOW_DEPRECATED_READPARAM
+ };
+ Maybe<Caret> mCaret;
+
+ struct TextRectArray final {
+ uint32_t mStart;
+ RectArray mRects;
+
+ explicit TextRectArray(uint32_t aStartOffset) : mStart(aStartOffset) {}
+
+ bool HasRects() const { return Length() > 0; }
+ uint32_t StartOffset() const { return mStart; }
+ uint32_t EndOffset() const {
+ CheckedInt<uint32_t> endOffset =
+ CheckedInt<uint32_t>(mStart) + mRects.Length();
+ return endOffset.isValid() ? endOffset.value() : UINT32_MAX;
+ }
+ uint32_t Length() const { return EndOffset() - mStart; }
+ bool IsOffsetInRange(uint32_t aOffset) const {
+ return StartOffset() <= aOffset && aOffset < EndOffset();
+ }
+ bool IsRangeCompletelyInRange(uint32_t aOffset, uint32_t aLength) const {
+ CheckedInt<uint32_t> endOffset = CheckedInt<uint32_t>(aOffset) + aLength;
+ if (NS_WARN_IF(!endOffset.isValid())) {
+ return false;
+ }
+ return IsOffsetInRange(aOffset) && aOffset + aLength <= EndOffset();
+ }
+ bool IsOverlappingWith(uint32_t aOffset, uint32_t aLength) const {
+ if (!HasRects() || aOffset == UINT32_MAX || !aLength) {
+ return false;
+ }
+ CheckedInt<uint32_t> endOffset = CheckedInt<uint32_t>(aOffset) + aLength;
+ if (NS_WARN_IF(!endOffset.isValid())) {
+ return false;
+ }
+ return aOffset < EndOffset() && endOffset.value() > mStart;
+ }
+ LayoutDeviceIntRect GetRect(uint32_t aOffset) const;
+ LayoutDeviceIntRect GetUnionRect(uint32_t aOffset, uint32_t aLength) const;
+ LayoutDeviceIntRect GetUnionRectAsFarAsPossible(
+ uint32_t aOffset, uint32_t aLength, bool aRoundToExistingOffset) const;
+
+ friend std::ostream& operator<<(std::ostream& aStream,
+ const TextRectArray& aTextRectArray) {
+ aStream << "{ mStart=" << aTextRectArray.mStart
+ << ", mRects={ Length()=" << aTextRectArray.Length();
+ if (aTextRectArray.HasRects()) {
+ aStream << ", Elements()=[ ";
+ static constexpr uint32_t kMaxPrintRects = 4;
+ const uint32_t kFirstHalf = aTextRectArray.Length() <= kMaxPrintRects
+ ? UINT32_MAX
+ : (kMaxPrintRects + 1) / 2;
+ const uint32_t kSecondHalf =
+ aTextRectArray.Length() <= kMaxPrintRects ? 0 : kMaxPrintRects / 2;
+ for (uint32_t i = 0; i < aTextRectArray.Length(); i++) {
+ if (i > 0) {
+ aStream << ", ";
+ }
+ aStream << ToString(aTextRectArray.mRects[i]).c_str();
+ if (i + 1 == kFirstHalf) {
+ aStream << " ...";
+ i = aTextRectArray.Length() - kSecondHalf - 1;
+ }
+ }
+ }
+ return aStream << " ] } }";
+ }
+
+ private:
+ TextRectArray() = default;
+
+ friend struct IPC::ParamTraits<ContentCache::TextRectArray>;
+ ALLOW_DEPRECATED_READPARAM
+ };
+ Maybe<TextRectArray> mTextRectArray;
+ Maybe<TextRectArray> mLastCommitStringTextRectArray;
+
+ LayoutDeviceIntRect mEditorRect;
+
+ friend class ContentCacheInParent;
+ friend struct IPC::ParamTraits<ContentCache>;
+ friend struct IPC::ParamTraits<ContentCache::Selection>;
+ friend struct IPC::ParamTraits<ContentCache::Caret>;
+ friend struct IPC::ParamTraits<ContentCache::TextRectArray>;
+ friend std::ostream& operator<<(
+ std::ostream& aStream,
+ const Selection& aSelection); // For e(Prev|Next)CharRect
+ ALLOW_DEPRECATED_READPARAM
+};
+
+class ContentCacheInChild final : public ContentCache {
+ public:
+ ContentCacheInChild() = default;
+
+ /**
+ * Called when composition event will be dispatched in this process from
+ * PuppetWidget.
+ */
+ void OnCompositionEvent(const WidgetCompositionEvent& aCompositionEvent);
+
+ /**
+ * When IME loses focus, this should be called and making this forget the
+ * content for reducing footprint.
+ */
+ void Clear();
+
+ /**
+ * Cache*() retrieves the latest content information and store them.
+ * Be aware, CacheSelection() calls CacheCaretAndTextRects(),
+ * CacheCaretAndTextRects() calls CacheCaret() and CacheTextRects(), and
+ * CacheText() calls CacheSelection(). So, related data is also retrieved
+ * automatically.
+ */
+ bool CacheEditorRect(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+ bool CacheCaretAndTextRects(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+ bool CacheText(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+
+ bool CacheAll(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+
+ /**
+ * SetSelection() modifies selection with specified raw data. And also this
+ * tries to retrieve text rects too.
+ *
+ * @return true if the selection is cached. Otherwise, false.
+ */
+ [[nodiscard]] bool SetSelection(
+ nsIWidget* aWidget,
+ const IMENotification::SelectionChangeDataBase& aSelectionChangeData);
+
+ private:
+ bool QueryCharRect(nsIWidget* aWidget, uint32_t aOffset,
+ LayoutDeviceIntRect& aCharRect) const;
+ bool QueryCharRectArray(nsIWidget* aWidget, uint32_t aOffset,
+ uint32_t aLength, RectArray& aCharRectArray) const;
+ bool CacheSelection(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+ bool CacheCaret(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+ bool CacheTextRects(nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+
+ // Once composition is committed, all of the commit string may be composed
+ // again by Kakutei-Undo of Japanese IME. Therefore, we need to keep
+ // storing the last composition start to cache all character rects of the
+ // last commit string.
+ Maybe<OffsetAndData<uint32_t>> mLastCommit;
+};
+
+class ContentCacheInParent final : public ContentCache {
+ public:
+ explicit ContentCacheInParent(dom::BrowserParent& aBrowserParent);
+
+ /**
+ * AssignContent() is called when BrowserParent receives ContentCache from
+ * the content process. This doesn't copy composition information because
+ * it's managed by BrowserParent itself.
+ */
+ void AssignContent(const ContentCache& aOther, nsIWidget* aWidget,
+ const IMENotification* aNotification = nullptr);
+
+ /**
+ * HandleQueryContentEvent() sets content data to aEvent.mReply.
+ *
+ * For eQuerySelectedText, fail if the cache doesn't contain the whole
+ * selected range. (This shouldn't happen because PuppetWidget should have
+ * already sent the whole selection.)
+ *
+ * For eQueryTextContent, fail only if the cache doesn't overlap with
+ * the queried range. Note the difference from above. We use
+ * this behavior because a normal eQueryTextContent event is allowed to
+ * have out-of-bounds offsets, so that widget can request content without
+ * knowing the exact length of text. It's up to widget to handle cases when
+ * the returned offset/length are different from the queried offset/length.
+ *
+ * For eQueryTextRect, fail if cached offset/length aren't equals to input.
+ * Cocoa widget always queries selected offset, so it works on it.
+ *
+ * For eQueryCaretRect, fail if cached offset isn't equals to input
+ *
+ * For eQueryEditorRect, always success
+ */
+ bool HandleQueryContentEvent(WidgetQueryContentEvent& aEvent,
+ nsIWidget* aWidget) const;
+
+ /**
+ * OnCompositionEvent() should be called before sending composition string.
+ * This returns true if the event should be sent. Otherwise, false.
+ */
+ bool OnCompositionEvent(const WidgetCompositionEvent& aCompositionEvent);
+
+ /**
+ * OnSelectionEvent() should be called before sending selection event.
+ */
+ void OnSelectionEvent(const WidgetSelectionEvent& aSelectionEvent);
+
+ /**
+ * OnEventNeedingAckHandled() should be called after the child process
+ * handles a sent event which needs acknowledging.
+ *
+ * WARNING: This may send notifications to IME. That might cause destroying
+ * BrowserParent or aWidget. Therefore, the caller must not destroy
+ * this instance during a call of this method.
+ */
+ void OnEventNeedingAckHandled(nsIWidget* aWidget, EventMessage aMessage);
+
+ /**
+ * RequestIMEToCommitComposition() requests aWidget to commit or cancel
+ * composition. If it's handled synchronously, this returns true.
+ *
+ * @param aWidget The widget to be requested to commit or cancel
+ * the composition.
+ * @param aCancel When the caller tries to cancel the composition, true.
+ * Otherwise, i.e., tries to commit the composition, false.
+ * @param aCommittedString The committed string (i.e., the last data of
+ * dispatched composition events during requesting
+ * IME to commit composition.
+ * @return Whether the composition is actually committed
+ * synchronously.
+ */
+ bool RequestIMEToCommitComposition(nsIWidget* aWidget, bool aCancel,
+ nsAString& aCommittedString);
+
+ /**
+ * MaybeNotifyIME() may notify IME of the notification. If child process
+ * hasn't been handled all sending events yet, this stores the notification
+ * and flush it later.
+ */
+ void MaybeNotifyIME(nsIWidget* aWidget, const IMENotification& aNotification);
+
+ private:
+ IMENotification mPendingSelectionChange;
+ IMENotification mPendingTextChange;
+ IMENotification mPendingLayoutChange;
+ IMENotification mPendingCompositionUpdate;
+
+#if MOZ_DIAGNOSTIC_ASSERT_ENABLED
+ // Log of event messages to be output to crash report.
+ nsTArray<EventMessage> mDispatchedEventMessages;
+ nsTArray<EventMessage> mReceivedEventMessages;
+ // Log of RequestIMEToCommitComposition() in the last 2 compositions.
+ enum class RequestIMEToCommitCompositionResult : uint8_t {
+ eToOldCompositionReceived,
+ eToCommittedCompositionReceived,
+ eReceivedAfterBrowserParentBlur,
+ eReceivedButNoTextComposition,
+ eHandledAsynchronously,
+ eHandledSynchronously,
+ };
+ const char* ToReadableText(
+ RequestIMEToCommitCompositionResult aResult) const {
+ switch (aResult) {
+ case RequestIMEToCommitCompositionResult::eToOldCompositionReceived:
+ return "Commit request is not handled because it's for "
+ "older composition";
+ case RequestIMEToCommitCompositionResult::eToCommittedCompositionReceived:
+ return "Commit request is not handled because BrowserParent has "
+ "already "
+ "sent commit event for the composition";
+ case RequestIMEToCommitCompositionResult::eReceivedAfterBrowserParentBlur:
+ return "Commit request is handled with stored composition string "
+ "because BrowserParent has already lost focus";
+ case RequestIMEToCommitCompositionResult::eReceivedButNoTextComposition:
+ return "Commit request is not handled because there is no "
+ "TextCompsition instance";
+ case RequestIMEToCommitCompositionResult::eHandledAsynchronously:
+ return "Commit request is handled but IME doesn't commit current "
+ "composition synchronously";
+ case RequestIMEToCommitCompositionResult::eHandledSynchronously:
+ return "Commit reqeust is handled synchronously";
+ default:
+ return "Unknown reason";
+ }
+ }
+ nsTArray<RequestIMEToCommitCompositionResult>
+ mRequestIMEToCommitCompositionResults;
+#endif // MOZ_DIAGNOSTIC_ASSERT_ENABLED
+
+ // mBrowserParent is owner of the instance.
+ dom::BrowserParent& MOZ_NON_OWNING_REF mBrowserParent;
+ // mCompositionString is composition string which were sent to the remote
+ // process but not yet committed in the remote process.
+ nsString mCompositionString;
+ // This is not nullptr only while the instance is requesting IME to
+ // composition. Then, data value of dispatched composition events should
+ // be stored into the instance.
+ nsAString* mCommitStringByRequest;
+ // mPendingEventsNeedingAck is increased before sending a composition event or
+ // a selection event and decreased after they are received in the child
+ // process.
+ uint32_t mPendingEventsNeedingAck;
+ // mCompositionStartInChild stores current composition start offset in the
+ // remote process.
+ Maybe<uint32_t> mCompositionStartInChild;
+ // mPendingCommitLength is commit string length of the first pending
+ // composition. This is used by relative offset query events when querying
+ // new composition start offset.
+ // Note that when mPendingCompositionCount is not 0, i.e., there are 2 or
+ // more pending compositions, this cache won't be used because in such case,
+ // anyway ContentCacheInParent cannot return proper character rect.
+ uint32_t mPendingCommitLength;
+ // mPendingCompositionCount is number of compositions which started in widget
+ // but not yet handled in the child process.
+ uint8_t mPendingCompositionCount;
+ // mPendingCommitCount is number of eCompositionCommit(AsIs) events which
+ // were sent to the child process but not yet handled in it.
+ uint8_t mPendingCommitCount;
+ // mWidgetHasComposition is true when the widget in this process thinks that
+ // IME has composition. So, this is set to true when eCompositionStart is
+ // dispatched and set to false when eCompositionCommit(AsIs) is dispatched.
+ bool mWidgetHasComposition;
+ // mIsChildIgnoringCompositionEvents is set to true if the child process
+ // requests commit composition whose commit has already been sent to it.
+ // Then, set to false when the child process ignores the commit event.
+ bool mIsChildIgnoringCompositionEvents;
+
+ ContentCacheInParent() = delete;
+
+ /**
+ * When following methods' aRoundToExistingOffset is true, even if specified
+ * offset or range is out of bounds, the result is computed with the existing
+ * cache forcibly.
+ */
+ bool GetCaretRect(uint32_t aOffset, bool aRoundToExistingOffset,
+ LayoutDeviceIntRect& aCaretRect) const;
+ bool GetTextRect(uint32_t aOffset, bool aRoundToExistingOffset,
+ LayoutDeviceIntRect& aTextRect) const;
+ bool GetUnionTextRects(uint32_t aOffset, uint32_t aLength,
+ bool aRoundToExistingOffset,
+ LayoutDeviceIntRect& aUnionTextRect) const;
+
+ void FlushPendingNotifications(nsIWidget* aWidget);
+
+#if MOZ_DIAGNOSTIC_ASSERT_ENABLED
+ /**
+ * Remove unnecessary messages from mDispatchedEventMessages and
+ * mReceivedEventMessages.
+ */
+ void RemoveUnnecessaryEventMessageLog();
+
+ /**
+ * Append event message log to aLog.
+ */
+ void AppendEventMessageLog(nsACString& aLog) const;
+#endif // #if MOZ_DIAGNOSTIC_ASSERT_ENABLED
+};
+
+} // namespace mozilla
+
+#endif // mozilla_ContentCache_h