widget/ContentCache.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=8 et :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #ifndef mozilla_ContentCache_h
   9 #define mozilla_ContentCache_h
  10
  11 #include <stdint.h>
  12
  13 #include "mozilla/widget/IMEData.h"
  14 #include "mozilla/ipc/IPCForwards.h"
  15 #include "mozilla/Assertions.h"
  16 #include "mozilla/CheckedInt.h"
  17 #include "mozilla/EventForwards.h"
  18 #include "mozilla/Maybe.h"
  19 #include "mozilla/ToString.h"
  20 #include "mozilla/WritingModes.h"
  21 #include "nsString.h"
  22 #include "nsTArray.h"
  23 #include "Units.h"
  24
  25 class nsIWidget;
  26
  27 namespace mozilla {
  28
  29 class ContentCacheInParent;
  30
  31 namespace dom {
  32 class BrowserParent;
  33 }  // namespace dom
  34
  35 /**
  36  * ContentCache stores various information of the child content.
  37  * This class has members which are necessary both in parent process and
  38  * content process.
  39  */
  40
  41 class ContentCache {
  42  public:
  43   typedef CopyableTArray<LayoutDeviceIntRect> RectArray;
  44   typedef widget::IMENotification IMENotification;
  45
  46   ContentCache() = default;
  47
  48  protected:
  49   // Whole text in the target
  50   Maybe<nsString> mText;
  51
  52   // Start offset of the composition string.
  53   Maybe<uint32_t> mCompositionStart;
  54
  55   enum { ePrevCharRect = 1, eNextCharRect = 0 };
  56
  57   struct Selection final {
  58     // Following values are offset in "flat text".
  59     uint32_t mAnchor;
  60     uint32_t mFocus;
  61
  62     WritingMode mWritingMode;
  63
  64     bool mHasRange;
  65
  66     // Character rects at previous and next character of mAnchor and mFocus.
  67     // The reason why ContentCache needs to store each previous character of
  68     // them is IME may query character rect of the last character of a line
  69     // when caret is at the end of the line.
  70     // Note that use ePrevCharRect and eNextCharRect for accessing each item.
  71     LayoutDeviceIntRect mAnchorCharRects[2];
  72     LayoutDeviceIntRect mFocusCharRects[2];
  73
  74     // Whole rect of selected text. This is empty if the selection is collapsed.
  75     LayoutDeviceIntRect mRect;
  76
  77     Selection() : mAnchor(UINT32_MAX), mFocus(UINT32_MAX), mHasRange(false) {
  78       ClearRects();
  79     };
  80
  81     explicit Selection(
  82         const IMENotification::SelectionChangeDataBase& aSelectionChangeData)
  83         : mAnchor(UINT32_MAX),
  84           mFocus(UINT32_MAX),
  85           mWritingMode(aSelectionChangeData.GetWritingMode()),
  86           mHasRange(aSelectionChangeData.HasRange()) {
  87       if (mHasRange) {
  88         mAnchor = aSelectionChangeData.AnchorOffset();
  89         mFocus = aSelectionChangeData.FocusOffset();
  90       }
  91     }
  92
  93     explicit Selection(const WidgetQueryContentEvent& aQuerySelectedTextEvent);
  94
  95     void ClearRects() {
  96       for (auto& rect : mAnchorCharRects) {
  97         rect.SetEmpty();
  98       }
  99       for (auto& rect : mFocusCharRects) {
 100         rect.SetEmpty();
 101       }
 102       mRect.SetEmpty();
 103     }
 104     bool HasRects() const {
 105       for (auto& rect : mAnchorCharRects) {
 106         if (!rect.IsEmpty()) {
 107           return true;
 108         }
 109       }
 110       for (auto& rect : mFocusCharRects) {
 111         if (!rect.IsEmpty()) {
 112           return true;
 113         }
 114       }
 115       return !mRect.IsEmpty();
 116     }
 117
 118     bool IsCollapsed() const { return !mHasRange || mFocus == mAnchor; }
 119     bool Reversed() const {
 120       MOZ_ASSERT(mHasRange);
 121       return mFocus < mAnchor;
 122     }
 123     uint32_t StartOffset() const {
 124       MOZ_ASSERT(mHasRange);
 125       return Reversed() ? mFocus : mAnchor;
 126     }
 127     uint32_t EndOffset() const {
 128       MOZ_ASSERT(mHasRange);
 129       return Reversed() ? mAnchor : mFocus;
 130     }
 131     uint32_t Length() const {
 132       MOZ_ASSERT(mHasRange);
 133       return Reversed() ? mAnchor - mFocus : mFocus - mAnchor;
 134     }
 135     LayoutDeviceIntRect StartCharRect() const {
 136       return Reversed() ? mFocusCharRects[eNextCharRect]
 137                         : mAnchorCharRects[eNextCharRect];
 138     }
 139     LayoutDeviceIntRect EndCharRect() const {
 140       return Reversed() ? mAnchorCharRects[eNextCharRect]
 141                         : mFocusCharRects[eNextCharRect];
 142     }
 143
 144     friend std::ostream& operator<<(std::ostream& aStream,
 145                                     const Selection& aSelection) {
 146       aStream << "{ ";
 147       if (!aSelection.mHasRange) {
 148         aStream << "HasRange()=false";
 149       } else {
 150         aStream << "mAnchor=" << aSelection.mAnchor
 151                 << ", mFocus=" << aSelection.mFocus << ", mWritingMode="
 152                 << ToString(aSelection.mWritingMode).c_str();
 153       }
 154       if (aSelection.HasRects()) {
 155         if (aSelection.mAnchor > 0) {
 156           aStream << ", mAnchorCharRects[ePrevCharRect]="
 157                   << aSelection.mAnchorCharRects[ContentCache::ePrevCharRect];
 158         }
 159         aStream << ", mAnchorCharRects[eNextCharRect]="
 160                 << aSelection.mAnchorCharRects[ContentCache::eNextCharRect];
 161         if (aSelection.mFocus > 0) {
 162           aStream << ", mFocusCharRects[ePrevCharRect]="
 163                   << aSelection.mFocusCharRects[ContentCache::ePrevCharRect];
 164         }
 165         aStream << ", mFocusCharRects[eNextCharRect]="
 166                 << aSelection.mFocusCharRects[ContentCache::eNextCharRect]
 167                 << ", mRect=" << aSelection.mRect;
 168       }
 169       if (aSelection.mHasRange) {
 170         aStream << ", Reversed()=" << (aSelection.Reversed() ? "true" : "false")
 171                 << ", StartOffset()=" << aSelection.StartOffset()
 172                 << ", EndOffset()=" << aSelection.EndOffset()
 173                 << ", IsCollapsed()="
 174                 << (aSelection.IsCollapsed() ? "true" : "false")
 175                 << ", Length()=" << aSelection.Length();
 176       }
 177       aStream << " }";
 178       return aStream;
 179     }
 180   };
 181   Maybe<Selection> mSelection;
 182
 183   // Stores first char rect because Yosemite's Japanese IME sometimes tries
 184   // to query it.  If there is no text, this is caret rect.
 185   LayoutDeviceIntRect mFirstCharRect;
 186
 187   struct Caret final {
 188     uint32_t mOffset;
 189     LayoutDeviceIntRect mRect;
 190
 191     explicit Caret(uint32_t aOffset, LayoutDeviceIntRect aCaretRect)
 192         : mOffset(aOffset), mRect(aCaretRect) {}
 193
 194     uint32_t Offset() const { return mOffset; }
 195     bool HasRect() const { return !mRect.IsEmpty(); }
 196
 197     friend std::ostream& operator<<(std::ostream& aStream,
 198                                     const Caret& aCaret) {
 199       aStream << "{ mOffset=" << aCaret.mOffset;
 200       if (aCaret.HasRect()) {
 201         aStream << ", mRect=" << aCaret.mRect;
 202       }
 203       return aStream << " }";
 204     }
 205
 206    private:
 207     Caret() = default;
 208
 209     friend struct IPC::ParamTraits<ContentCache::Caret>;
 210     ALLOW_DEPRECATED_READPARAM
 211   };
 212   Maybe<Caret> mCaret;
 213
 214   struct TextRectArray final {
 215     uint32_t mStart;
 216     RectArray mRects;
 217
 218     explicit TextRectArray(uint32_t aStartOffset) : mStart(aStartOffset) {}
 219
 220     bool HasRects() const { return Length() > 0; }
 221     uint32_t StartOffset() const { return mStart; }
 222     uint32_t EndOffset() const {
 223       CheckedInt<uint32_t> endOffset =
 224           CheckedInt<uint32_t>(mStart) + mRects.Length();
 225       return endOffset.isValid() ? endOffset.value() : UINT32_MAX;
 226     }
 227     uint32_t Length() const { return EndOffset() - mStart; }
 228     bool IsOffsetInRange(uint32_t aOffset) const {
 229       return StartOffset() <= aOffset && aOffset < EndOffset();
 230     }
 231     bool IsRangeCompletelyInRange(uint32_t aOffset, uint32_t aLength) const {
 232       CheckedInt<uint32_t> endOffset = CheckedInt<uint32_t>(aOffset) + aLength;
 233       if (NS_WARN_IF(!endOffset.isValid())) {
 234         return false;
 235       }
 236       return IsOffsetInRange(aOffset) && aOffset + aLength <= EndOffset();
 237     }
 238     bool IsOverlappingWith(uint32_t aOffset, uint32_t aLength) const {
 239       if (!HasRects() || aOffset == UINT32_MAX || !aLength) {
 240         return false;
 241       }
 242       CheckedInt<uint32_t> endOffset = CheckedInt<uint32_t>(aOffset) + aLength;
 243       if (NS_WARN_IF(!endOffset.isValid())) {
 244         return false;
 245       }
 246       return aOffset < EndOffset() && endOffset.value() > mStart;
 247     }
 248     LayoutDeviceIntRect GetRect(uint32_t aOffset) const;
 249     LayoutDeviceIntRect GetUnionRect(uint32_t aOffset, uint32_t aLength) const;
 250     LayoutDeviceIntRect GetUnionRectAsFarAsPossible(
 251         uint32_t aOffset, uint32_t aLength, bool aRoundToExistingOffset) const;
 252
 253     friend std::ostream& operator<<(std::ostream& aStream,
 254                                     const TextRectArray& aTextRectArray) {
 255       aStream << "{ mStart=" << aTextRectArray.mStart
 256               << ", mRects={ Length()=" << aTextRectArray.Length();
 257       if (aTextRectArray.HasRects()) {
 258         aStream << ", Elements()=[ ";
 259         static constexpr uint32_t kMaxPrintRects = 4;
 260         const uint32_t kFirstHalf = aTextRectArray.Length() <= kMaxPrintRects
 261                                         ? UINT32_MAX
 262                                         : (kMaxPrintRects + 1) / 2;
 263         const uint32_t kSecondHalf =
 264             aTextRectArray.Length() <= kMaxPrintRects ? 0 : kMaxPrintRects / 2;
 265         for (uint32_t i = 0; i < aTextRectArray.Length(); i++) {
 266           if (i > 0) {
 267             aStream << ", ";
 268           }
 269           aStream << ToString(aTextRectArray.mRects[i]).c_str();
 270           if (i + 1 == kFirstHalf) {
 271             aStream << " ...";
 272             i = aTextRectArray.Length() - kSecondHalf - 1;
 273           }
 274         }
 275       }
 276       return aStream << " ] } }";
 277     }
 278
 279    private:
 280     TextRectArray() = default;
 281
 282     friend struct IPC::ParamTraits<ContentCache::TextRectArray>;
 283     ALLOW_DEPRECATED_READPARAM
 284   };
 285   Maybe<TextRectArray> mTextRectArray;
 286   Maybe<TextRectArray> mLastCommitStringTextRectArray;
 287
 288   LayoutDeviceIntRect mEditorRect;
 289
 290   friend class ContentCacheInParent;
 291   friend struct IPC::ParamTraits<ContentCache>;
 292   friend struct IPC::ParamTraits<ContentCache::Selection>;
 293   friend struct IPC::ParamTraits<ContentCache::Caret>;
 294   friend struct IPC::ParamTraits<ContentCache::TextRectArray>;
 295   friend std::ostream& operator<<(
 296       std::ostream& aStream,
 297       const Selection& aSelection);  // For e(Prev|Next)CharRect
 298   ALLOW_DEPRECATED_READPARAM
 299 };
 300
 301 class ContentCacheInChild final : public ContentCache {
 302  public:
 303   ContentCacheInChild() = default;
 304
 305   /**
 306    * Called when composition event will be dispatched in this process from
 307    * PuppetWidget.
 308    */
 309   void OnCompositionEvent(const WidgetCompositionEvent& aCompositionEvent);
 310
 311   /**
 312    * When IME loses focus, this should be called and making this forget the
 313    * content for reducing footprint.
 314    */
 315   void Clear();
 316
 317   /**
 318    * Cache*() retrieves the latest content information and store them.
 319    * Be aware, CacheSelection() calls CacheTextRects(), and also CacheText()
 320    * calls CacheSelection().  So, related data is also retrieved automatically.
 321    */
 322   bool CacheEditorRect(nsIWidget* aWidget,
 323                        const IMENotification* aNotification = nullptr);
 324   bool CacheSelection(nsIWidget* aWidget,
 325                       const IMENotification* aNotification = nullptr);
 326   bool CacheText(nsIWidget* aWidget,
 327                  const IMENotification* aNotification = nullptr);
 328
 329   bool CacheAll(nsIWidget* aWidget,
 330                 const IMENotification* aNotification = nullptr);
 331
 332   /**
 333    * SetSelection() modifies selection with specified raw data. And also this
 334    * tries to retrieve text rects too.
 335    */
 336   void SetSelection(
 337       nsIWidget* aWidget,
 338       const IMENotification::SelectionChangeDataBase& aSelectionChangeData);
 339
 340  private:
 341   bool QueryCharRect(nsIWidget* aWidget, uint32_t aOffset,
 342                      LayoutDeviceIntRect& aCharRect) const;
 343   bool QueryCharRectArray(nsIWidget* aWidget, uint32_t aOffset,
 344                           uint32_t aLength, RectArray& aCharRectArray) const;
 345   bool CacheCaret(nsIWidget* aWidget,
 346                   const IMENotification* aNotification = nullptr);
 347   bool CacheTextRects(nsIWidget* aWidget,
 348                       const IMENotification* aNotification = nullptr);
 349
 350   // Once composition is committed, all of the commit string may be composed
 351   // again by Kakutei-Undo of Japanese IME.  Therefore, we need to keep
 352   // storing the last composition start to cache all character rects of the
 353   // last commit string.
 354   Maybe<OffsetAndData<uint32_t>> mLastCommit;
 355 };
 356
 357 class ContentCacheInParent final : public ContentCache {
 358  public:
 359   explicit ContentCacheInParent(dom::BrowserParent& aBrowserParent);
 360
 361   /**
 362    * AssignContent() is called when BrowserParent receives ContentCache from
 363    * the content process.  This doesn't copy composition information because
 364    * it's managed by BrowserParent itself.
 365    */
 366   void AssignContent(const ContentCache& aOther, nsIWidget* aWidget,
 367                      const IMENotification* aNotification = nullptr);
 368
 369   /**
 370    * HandleQueryContentEvent() sets content data to aEvent.mReply.
 371    *
 372    * For eQuerySelectedText, fail if the cache doesn't contain the whole
 373    *  selected range. (This shouldn't happen because PuppetWidget should have
 374    *  already sent the whole selection.)
 375    *
 376    * For eQueryTextContent, fail only if the cache doesn't overlap with
 377    *  the queried range. Note the difference from above. We use
 378    *  this behavior because a normal eQueryTextContent event is allowed to
 379    *  have out-of-bounds offsets, so that widget can request content without
 380    *  knowing the exact length of text. It's up to widget to handle cases when
 381    *  the returned offset/length are different from the queried offset/length.
 382    *
 383    * For eQueryTextRect, fail if cached offset/length aren't equals to input.
 384    *   Cocoa widget always queries selected offset, so it works on it.
 385    *
 386    * For eQueryCaretRect, fail if cached offset isn't equals to input
 387    *
 388    * For eQueryEditorRect, always success
 389    */
 390   bool HandleQueryContentEvent(WidgetQueryContentEvent& aEvent,
 391                                nsIWidget* aWidget) const;
 392
 393   /**
 394    * OnCompositionEvent() should be called before sending composition string.
 395    * This returns true if the event should be sent.  Otherwise, false.
 396    */
 397   bool OnCompositionEvent(const WidgetCompositionEvent& aCompositionEvent);
 398
 399   /**
 400    * OnSelectionEvent() should be called before sending selection event.
 401    */
 402   void OnSelectionEvent(const WidgetSelectionEvent& aSelectionEvent);
 403
 404   /**
 405    * OnEventNeedingAckHandled() should be called after the child process
 406    * handles a sent event which needs acknowledging.
 407    *
 408    * WARNING: This may send notifications to IME.  That might cause destroying
 409    *          BrowserParent or aWidget.  Therefore, the caller must not destroy
 410    *          this instance during a call of this method.
 411    */
 412   void OnEventNeedingAckHandled(nsIWidget* aWidget, EventMessage aMessage);
 413
 414   /**
 415    * RequestIMEToCommitComposition() requests aWidget to commit or cancel
 416    * composition.  If it's handled synchronously, this returns true.
 417    *
 418    * @param aWidget     The widget to be requested to commit or cancel
 419    *                    the composition.
 420    * @param aCancel     When the caller tries to cancel the composition, true.
 421    *                    Otherwise, i.e., tries to commit the composition, false.
 422    * @param aCommittedString    The committed string (i.e., the last data of
 423    *                            dispatched composition events during requesting
 424    *                            IME to commit composition.
 425    * @return            Whether the composition is actually committed
 426    *                    synchronously.
 427    */
 428   bool RequestIMEToCommitComposition(nsIWidget* aWidget, bool aCancel,
 429                                      nsAString& aCommittedString);
 430
 431   /**
 432    * MaybeNotifyIME() may notify IME of the notification.  If child process
 433    * hasn't been handled all sending events yet, this stores the notification
 434    * and flush it later.
 435    */
 436   void MaybeNotifyIME(nsIWidget* aWidget, const IMENotification& aNotification);
 437
 438  private:
 439   IMENotification mPendingSelectionChange;
 440   IMENotification mPendingTextChange;
 441   IMENotification mPendingLayoutChange;
 442   IMENotification mPendingCompositionUpdate;
 443
 444 #if MOZ_DIAGNOSTIC_ASSERT_ENABLED
 445   // Log of event messages to be output to crash report.
 446   nsTArray<EventMessage> mDispatchedEventMessages;
 447   nsTArray<EventMessage> mReceivedEventMessages;
 448   // Log of RequestIMEToCommitComposition() in the last 2 compositions.
 449   enum class RequestIMEToCommitCompositionResult : uint8_t {
 450     eToOldCompositionReceived,
 451     eToCommittedCompositionReceived,
 452     eReceivedAfterBrowserParentBlur,
 453     eReceivedButNoTextComposition,
 454     eHandledAsynchronously,
 455     eHandledSynchronously,
 456   };
 457   const char* ToReadableText(
 458       RequestIMEToCommitCompositionResult aResult) const {
 459     switch (aResult) {
 460       case RequestIMEToCommitCompositionResult::eToOldCompositionReceived:
 461         return "Commit request is not handled because it's for "
 462                "older composition";
 463       case RequestIMEToCommitCompositionResult::eToCommittedCompositionReceived:
 464         return "Commit request is not handled because BrowserParent has "
 465                "already "
 466                "sent commit event for the composition";
 467       case RequestIMEToCommitCompositionResult::eReceivedAfterBrowserParentBlur:
 468         return "Commit request is handled with stored composition string "
 469                "because BrowserParent has already lost focus";
 470       case RequestIMEToCommitCompositionResult::eReceivedButNoTextComposition:
 471         return "Commit request is not handled because there is no "
 472                "TextCompsition instance";
 473       case RequestIMEToCommitCompositionResult::eHandledAsynchronously:
 474         return "Commit request is handled but IME doesn't commit current "
 475                "composition synchronously";
 476       case RequestIMEToCommitCompositionResult::eHandledSynchronously:
 477         return "Commit reqeust is handled synchronously";
 478       default:
 479         return "Unknown reason";
 480     }
 481   }
 482   nsTArray<RequestIMEToCommitCompositionResult>
 483       mRequestIMEToCommitCompositionResults;
 484 #endif  // MOZ_DIAGNOSTIC_ASSERT_ENABLED
 485
 486   // mBrowserParent is owner of the instance.
 487   dom::BrowserParent& MOZ_NON_OWNING_REF mBrowserParent;
 488   // mCompositionString is composition string which were sent to the remote
 489   // process but not yet committed in the remote process.
 490   nsString mCompositionString;
 491   // This is not nullptr only while the instance is requesting IME to
 492   // composition.  Then, data value of dispatched composition events should
 493   // be stored into the instance.
 494   nsAString* mCommitStringByRequest;
 495   // mPendingEventsNeedingAck is increased before sending a composition event or
 496   // a selection event and decreased after they are received in the child
 497   // process.
 498   uint32_t mPendingEventsNeedingAck;
 499   // mCompositionStartInChild stores current composition start offset in the
 500   // remote process.
 501   Maybe<uint32_t> mCompositionStartInChild;
 502   // mPendingCommitLength is commit string length of the first pending
 503   // composition.  This is used by relative offset query events when querying
 504   // new composition start offset.
 505   // Note that when mPendingCompositionCount is not 0, i.e., there are 2 or
 506   // more pending compositions, this cache won't be used because in such case,
 507   // anyway ContentCacheInParent cannot return proper character rect.
 508   uint32_t mPendingCommitLength;
 509   // mPendingCompositionCount is number of compositions which started in widget
 510   // but not yet handled in the child process.
 511   uint8_t mPendingCompositionCount;
 512   // mPendingCommitCount is number of eCompositionCommit(AsIs) events which
 513   // were sent to the child process but not yet handled in it.
 514   uint8_t mPendingCommitCount;
 515   // mWidgetHasComposition is true when the widget in this process thinks that
 516   // IME has composition.  So, this is set to true when eCompositionStart is
 517   // dispatched and set to false when eCompositionCommit(AsIs) is dispatched.
 518   bool mWidgetHasComposition;
 519   // mIsChildIgnoringCompositionEvents is set to true if the child process
 520   // requests commit composition whose commit has already been sent to it.
 521   // Then, set to false when the child process ignores the commit event.
 522   bool mIsChildIgnoringCompositionEvents;
 523
 524   ContentCacheInParent() = delete;
 525
 526   /**
 527    * When following methods' aRoundToExistingOffset is true, even if specified
 528    * offset or range is out of bounds, the result is computed with the existing
 529    * cache forcibly.
 530    */
 531   bool GetCaretRect(uint32_t aOffset, bool aRoundToExistingOffset,
 532                     LayoutDeviceIntRect& aCaretRect) const;
 533   bool GetTextRect(uint32_t aOffset, bool aRoundToExistingOffset,
 534                    LayoutDeviceIntRect& aTextRect) const;
 535   bool GetUnionTextRects(uint32_t aOffset, uint32_t aLength,
 536                          bool aRoundToExistingOffset,
 537                          LayoutDeviceIntRect& aUnionTextRect) const;
 538
 539   void FlushPendingNotifications(nsIWidget* aWidget);
 540
 541 #if MOZ_DIAGNOSTIC_ASSERT_ENABLED
 542   /**
 543    * Remove unnecessary messages from mDispatchedEventMessages and
 544    * mReceivedEventMessages.
 545    */
 546   void RemoveUnnecessaryEventMessageLog();
 547
 548   /**
 549    * Append event message log to aLog.
 550    */
 551   void AppendEventMessageLog(nsACString& aLog) const;
 552 #endif  // #if MOZ_DIAGNOSTIC_ASSERT_ENABLED
 553 };
 554
 555 }  // namespace mozilla
 556
 557 #endif  // mozilla_ContentCache_h