author Erica Wright <ewright@mozilla.com>
Fri, 28 Dec 2018 04:26:00 +0000
changeset 512272 7e75579b27d017c48a83e04db1588f7232cc750a
parent 508163 6f3709b3878117466168c40affa7bca0b60cf75b
child 532820 47813ecb1f4e0244ded2f7b938430bf52c927751
permissions -rw-r--r--
Bug 1512166 - Show blocked labels by default, hide when there's an exception. r=nhnt11 In the control panel, show the blocking category labels for tracking protection and cookie restrictions. Hide the label if the user has set an exception for that page. Differential Revision: https://phabricator.services.mozilla.com/D15212

/* -*- 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/Assertions.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/EventForwards.h"
#include "mozilla/WritingModes.h"
#include "nsIWidget.h"
#include "nsString.h"
#include "nsTArray.h"
#include "Units.h"

namespace mozilla {

class ContentCacheInParent;

namespace dom {
class TabParent;
}  // 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 {
  typedef InfallibleTArray<LayoutDeviceIntRect> RectArray;
  typedef widget::IMENotification IMENotification;


  // Whole text in the target
  nsString mText;

  // Start offset of the composition string.
  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;

    // 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) {}

    void Clear() {
      mAnchor = mFocus = UINT32_MAX;
      mWritingMode = WritingMode();

    void ClearAnchorCharRects() {
      for (size_t i = 0; i < ArrayLength(mAnchorCharRects); i++) {
    void ClearFocusCharRects() {
      for (size_t i = 0; i < ArrayLength(mFocusCharRects); i++) {

    bool IsValid() const {
      return mAnchor != UINT32_MAX && mFocus != UINT32_MAX;
    bool Collapsed() const {
                   "The caller should check if the selection is valid");
      return mFocus == mAnchor;
    bool Reversed() const {
                   "The caller should check if the selection is valid");
      return mFocus < mAnchor;
    uint32_t StartOffset() const {
                   "The caller should check if the selection is valid");
      return Reversed() ? mFocus : mAnchor;
    uint32_t EndOffset() const {
                   "The caller should check if the selection is valid");
      return Reversed() ? mAnchor : mFocus;
    uint32_t Length() const {
                   "The caller should check if the selection is valid");
      return Reversed() ? mAnchor - mFocus : mFocus - mAnchor;
    LayoutDeviceIntRect StartCharRect() const {
                   "The caller should check if the selection is valid");
      return Reversed() ? mFocusCharRects[eNextCharRect]
                        : mAnchorCharRects[eNextCharRect];
    LayoutDeviceIntRect EndCharRect() const {
                   "The caller should check if the selection is valid");
      return Reversed() ? mAnchorCharRects[eNextCharRect]
                        : mFocusCharRects[eNextCharRect];
  } mSelection;

  bool IsSelectionValid() const {
    return mSelection.IsValid() && mSelection.EndOffset() <= mText.Length();

  // 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;

    Caret() : mOffset(UINT32_MAX) {}

    void Clear() {
      mOffset = UINT32_MAX;

    bool IsValid() const { return mOffset != UINT32_MAX; }

    uint32_t Offset() const {
      NS_ASSERTION(IsValid(), "The caller should check if the caret is valid");
      return mOffset;
  } mCaret;

  struct TextRectArray final {
    uint32_t mStart;
    RectArray mRects;

    TextRectArray() : mStart(UINT32_MAX) {}

    void Clear() {
      mStart = UINT32_MAX;

    bool IsValid() const {
      if (mStart == UINT32_MAX) {
        return false;
      CheckedInt<uint32_t> endOffset =
          CheckedInt<uint32_t>(mStart) + mRects.Length();
      return endOffset.isValid();
    bool HasRects() const { return IsValid() && !mRects.IsEmpty(); }
    uint32_t StartOffset() const {
      NS_ASSERTION(IsValid(), "The caller should check if the caret is valid");
      return mStart;
    uint32_t EndOffset() const {
      NS_ASSERTION(IsValid(), "The caller should check if the caret is valid");
      if (!IsValid()) {
        return UINT32_MAX;
      return mStart + mRects.Length();
    bool InRange(uint32_t aOffset) const {
      return IsValid() && StartOffset() <= aOffset && aOffset < EndOffset();
    bool InRange(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 InRange(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;
  } mTextRectArray;

  LayoutDeviceIntRect mEditorRect;

  friend class ContentCacheInParent;
  friend struct IPC::ParamTraits<ContentCache>;

class ContentCacheInChild final : public ContentCache {

   * 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 CacheTextRects(), and also CacheText()
   * calls CacheSelection().  So, related data is also retrieved automatically.
  bool CacheEditorRect(nsIWidget* aWidget,
                       const IMENotification* aNotification = nullptr);
  bool CacheSelection(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.
  void SetSelection(nsIWidget* aWidget, uint32_t aStartOffset, uint32_t aLength,
                    bool aReversed, const WritingMode& aWritingMode);

  bool QueryCharRect(nsIWidget* aWidget, uint32_t aOffset,
                     LayoutDeviceIntRect& aCharRect) const;
  bool QueryCharRectArray(nsIWidget* aWidget, uint32_t aOffset,
                          uint32_t aLength, RectArray& aCharRectArray) const;
  bool CacheCaret(nsIWidget* aWidget,
                  const IMENotification* aNotification = nullptr);
  bool CacheTextRects(nsIWidget* aWidget,
                      const IMENotification* aNotification = nullptr);

class ContentCacheInParent final : public ContentCache {
  explicit ContentCacheInParent(dom::TabParent& aTabParent);

   * AssignContent() is called when TabParent receives ContentCache from
   * the content process.  This doesn't copy composition information because
   * it's managed by TabParent 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
   *          TabParent 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);

  IMENotification mPendingSelectionChange;
  IMENotification mPendingTextChange;
  IMENotification mPendingLayoutChange;
  IMENotification mPendingCompositionUpdate;

  // 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 {
  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 TabParent has already "
               "sent commit event for the composition";
      case RequestIMEToCommitCompositionResult::eReceivedAfterTabParentBlur:
        return "Commit request is handled with stored composition string "
               "because TabParent 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";
        return "Unknown reason";

  // mTabParent is owner of the instance.
  dom::TabParent& MOZ_NON_OWNING_REF mTabParent;
  // 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.
  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);

   * Remove unnecessary messages from mDispatchedEventMessages and
   * mReceivedEventMessages.
  void RemoveUnnecessaryEventMessageLog();

   * Append event message log to aLog.
  void AppendEventMessageLog(nsACString& aLog) const;

}  // namespace mozilla

#endif  // mozilla_ContentCache_h