/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_TextEvents_h__

#define mozilla_TextEvents_h__

#include <stdint.h>

#include "mozilla/Assertions.h"

#include "mozilla/BasicEvents.h"

#include "mozilla/CheckedInt.h"

#include "mozilla/EventForwards.h" // for KeyNameIndex, temporarily

#include "mozilla/FontRange.h"

#include "mozilla/TextRange.h"

#include "mozilla/WritingModes.h"

#include "mozilla/dom/KeyboardEventBinding.h"

#include "nsCOMPtr.h"

#include "nsISelectionController.h"

#include "nsISelectionListener.h"

#include "nsITransferable.h"

#include "nsRect.h"

#include "nsString.h"

#include "nsTArray.h"

class nsStringHashKey;

template<class, class> class nsDataHashtable;

/******************************************************************************

 * virtual keycode values

 ******************************************************************************/

enum

{

#define NS_DEFINE_VK(aDOMKeyName, aDOMKeyCode) NS_##aDOMKeyName = aDOMKeyCode,

#include "mozilla/VirtualKeyCodeList.h"

#undef NS_DEFINE_VK

  NS_VK_UNKNOWN = 0xFF

};

namespace mozilla {

enum : uint32_t

{

  eKeyLocationStandard = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_STANDARD,

  eKeyLocationLeft     = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_LEFT,

  eKeyLocationRight    = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_RIGHT,

  eKeyLocationNumpad   = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD

};

const nsCString GetDOMKeyCodeName(uint32_t aKeyCode);

namespace dom {

  class PBrowserParent;

  class PBrowserChild;

} // namespace dom

namespace plugins {

  class PPluginInstanceChild;

} // namespace plugins

enum class AccessKeyType

{

  // Handle access key for chrome.

  eChrome,

  // Handle access key for content.

  eContent,

  // Don't handle access key.

  eNone

};

/******************************************************************************

 * mozilla::AlternativeCharCode

 *

 * This stores alternative charCode values of a key event with some modifiers.

 * The stored values proper for testing shortcut key or access key.

 ******************************************************************************/

struct AlternativeCharCode

{

  AlternativeCharCode() :

    mUnshiftedCharCode(0), mShiftedCharCode(0)

  {

  }

  AlternativeCharCode(uint32_t aUnshiftedCharCode, uint32_t aShiftedCharCode) :

    mUnshiftedCharCode(aUnshiftedCharCode), mShiftedCharCode(aShiftedCharCode)

  {

  }

  uint32_t mUnshiftedCharCode;

  uint32_t mShiftedCharCode;

};

/******************************************************************************

 * mozilla::ShortcutKeyCandidate

 *

 * This stores a candidate of shortcut key combination.

 ******************************************************************************/

struct ShortcutKeyCandidate

{

  ShortcutKeyCandidate()

    : mCharCode(0)

    , mIgnoreShift(0)

  {

  }

  ShortcutKeyCandidate(uint32_t aCharCode, bool aIgnoreShift)

    : mCharCode(aCharCode)

    , mIgnoreShift(aIgnoreShift)

  {

  }

  // The mCharCode value which must match keyboard shortcut definition.

  uint32_t mCharCode;

  // true if Shift state can be ignored.  Otherwise, Shift key state must

  // match keyboard shortcut definition.

  bool mIgnoreShift;

};

/******************************************************************************

 * mozilla::IgnoreModifierState

 *

 * This stores flags for modifiers that should be ignored when matching

 * XBL handlers.

 ******************************************************************************/

struct IgnoreModifierState

{

  // When mShift is true, Shift key state will be ignored.

  bool mShift;

  // When mOS is true, OS key state will be ignored.

  bool mOS;

  IgnoreModifierState()

    : mShift(false)

    , mOS(false)

  {

  }

};

/******************************************************************************

 * mozilla::WidgetKeyboardEvent

 ******************************************************************************/

class WidgetKeyboardEvent : public WidgetInputEvent

{

private:

  friend class dom::PBrowserParent;

  friend class dom::PBrowserChild;

  friend struct IPC::ParamTraits<WidgetKeyboardEvent>;

protected:

  WidgetKeyboardEvent()

    : mNativeKeyEvent(nullptr)

    , mKeyCode(0)

    , mCharCode(0)

    , mPseudoCharCode(0)

    , mLocation(eKeyLocationStandard)

    , mUniqueId(0)

#ifdef XP_MACOSX

    , mNativeModifierFlags(0)

    , mNativeKeyCode(0)

#endif // #ifdef XP_MACOSX

    , mKeyNameIndex(KEY_NAME_INDEX_Unidentified)

    , mCodeNameIndex(CODE_NAME_INDEX_UNKNOWN)

    , mIsRepeat(false)

    , mIsComposing(false)

    , mIsSynthesizedByTIP(false)

    , mMaybeSkippableInRemoteProcess(true)

    , mEditCommandsForSingleLineEditorInitialized(false)

    , mEditCommandsForMultiLineEditorInitialized(false)

    , mEditCommandsForRichTextEditorInitialized(false)

  {

  }

public:

  virtual WidgetKeyboardEvent* AsKeyboardEvent() override { return this; }

  WidgetKeyboardEvent(bool aIsTrusted, EventMessage aMessage,

                      nsIWidget* aWidget,

                      EventClassID aEventClassID = eKeyboardEventClass)

    : WidgetInputEvent(aIsTrusted, aMessage, aWidget, aEventClassID)

    , mNativeKeyEvent(nullptr)

    , mKeyCode(0)

    , mCharCode(0)

    , mPseudoCharCode(0)

    , mLocation(eKeyLocationStandard)

    , mUniqueId(0)

#ifdef XP_MACOSX

    , mNativeModifierFlags(0)

    , mNativeKeyCode(0)

#endif // #ifdef XP_MACOSX

    , mKeyNameIndex(KEY_NAME_INDEX_Unidentified)

    , mCodeNameIndex(CODE_NAME_INDEX_UNKNOWN)

    , mIsRepeat(false)

    , mIsComposing(false)

    , mIsSynthesizedByTIP(false)

    , mMaybeSkippableInRemoteProcess(true)

    , mEditCommandsForSingleLineEditorInitialized(false)

    , mEditCommandsForMultiLineEditorInitialized(false)

    , mEditCommandsForRichTextEditorInitialized(false)

  {

    // If this is a keyboard event on a plugin, it shouldn't fired on content.

    if (IsKeyEventOnPlugin()) {

      mFlags.mOnlySystemGroupDispatchInContent = true;

      StopCrossProcessForwarding();

    }

  }

  static bool IsKeyDownOrKeyDownOnPlugin(EventMessage aMessage)

  {

    return aMessage == eKeyDown || aMessage == eKeyDownOnPlugin;

  }

  bool IsKeyDownOrKeyDownOnPlugin() const

  {

    return IsKeyDownOrKeyDownOnPlugin(mMessage);

  }

  static bool IsKeyUpOrKeyUpOnPlugin(EventMessage aMessage)

  {

    return aMessage == eKeyUp || aMessage == eKeyUpOnPlugin;

  }

  bool IsKeyUpOrKeyUpOnPlugin() const

  {

    return IsKeyUpOrKeyUpOnPlugin(mMessage);

  }

  static bool IsKeyEventOnPlugin(EventMessage aMessage)

  {

    return aMessage == eKeyDownOnPlugin || aMessage == eKeyUpOnPlugin;

  }

  bool IsKeyEventOnPlugin() const

  {

    return IsKeyEventOnPlugin(mMessage);

  }

  // IsInputtingText() and IsInputtingLineBreak() are used to check if

  // it should cause eKeyPress events even on web content.

  // UI Events defines that "keypress" event should be fired "if and only if

  // that key normally produces a character value".

  // <https://www.w3.org/TR/uievents/#event-type-keypress>

  // Additionally, for backward compatiblity with all existing browsers,

  // there is a spec issue for Enter key press.

  // <https://github.com/w3c/uievents/issues/183>

  bool IsInputtingText() const

  {

    // NOTE: On some keyboard layout, some characters are inputted with Control

    //       key or Alt key, but at that time, widget clears the modifier flag

    //       from eKeyPress event because our TextEditor won't handle eKeyPress

    //       events as inputting text (bug 1346832).

    // NOTE: There are some complicated issues of our traditional behavior.

    //       -- On Windows, KeyboardLayout::WillDispatchKeyboardEvent() clears

    //       MODIFIER_ALT and MODIFIER_CONTROL of eKeyPress event if it

    //       should be treated as inputting a character because AltGr is

    //       represented with both Alt key and Ctrl key are pressed, and

    //       some keyboard layouts may produces a character with Ctrl key.

    //       -- On Linux, KeymapWrapper doesn't have this hack since perhaps,

    //       we don't have any bug reports that user cannot input proper

    //       character with Alt and/or Ctrl key.

    //       -- On macOS, IMEInputHandler::WillDispatchKeyboardEvent() clears

    //       MODIFIER_ALT and MDOFIEIR_CONTROL of eKeyPress event only when

    //       TextInputHandler::InsertText() has been called for the event.

    //       I.e., they are cleared only when an editor has focus (even if IME

    //       is disabled in password field or by |ime-mode: disabled;|) because

    //       TextInputHandler::InsertText() is called while

    //       TextInputHandler::HandleKeyDownEvent() calls interpretKeyEvents:

    //       to notify text input processor of Cocoa (including IME).  In other

    //       words, when we need to disable IME completey when no editor has

    //       focus, we cannot call interpretKeyEvents:.  So,

    //       TextInputHandler::InsertText() won't be called when no editor has

    //       focus so that neither MODIFIER_ALT nor MODIFIER_CONTROL is

    //       cleared.  So, fortunately, altKey and ctrlKey values of "keypress"

    //       events are same as the other browsers only when no editor has

    //       focus.

    // NOTE: As mentioned above, for compatibility with the other browsers on

    //       macOS, we should keep MODIFIER_ALT and MODIFIER_CONTROL flags of

    //       eKeyPress events when no editor has focus.  However, Alt key,

    //       labeled "option" on keyboard for Mac, is AltGraph key on the other

    //       platforms.  So, even if MODIFIER_ALT is set, we need to dispatch

    //       eKeyPress event even on web content unless mCharCode is 0.

    //       Therefore, we need to ignore MODIFIER_ALT flag here only on macOS.

    return mMessage == eKeyPress &&

           mCharCode &&

           !(mModifiers & (

#ifndef XP_MACOSX

                           // So, ignore MODIFIER_ALT only on macOS since

                           // option key is used as AltGraph key on macOS.

                           MODIFIER_ALT |

#endif // #ifndef XP_MAXOSX

                           MODIFIER_CONTROL |

                           MODIFIER_META |

                           MODIFIER_OS));

  }

  bool IsInputtingLineBreak() const

  {

    return mMessage == eKeyPress &&

           mKeyNameIndex == KEY_NAME_INDEX_Enter &&

           !(mModifiers & (MODIFIER_ALT |

                           MODIFIER_CONTROL |

                           MODIFIER_META |

                           MODIFIER_OS));

  }

  /**

   * ShouldKeyPressEventBeFiredOnContent() should be called only when the

   * instance is eKeyPress event.  This returns true when the eKeyPress

   * event should be fired even on content in the default event group.

   */

  bool ShouldKeyPressEventBeFiredOnContent() const

  {

    MOZ_DIAGNOSTIC_ASSERT(mMessage == eKeyPress);

    if (IsInputtingText() || IsInputtingLineBreak()) {

      return true;

    }

    // Ctrl + Enter won't cause actual input in our editor.

    // However, the other browsers fire keypress event in any platforms.

    // So, for compatibility with them, we should fire keypress event for

    // Ctrl + Enter too.

    return mMessage == eKeyPress &&

           mKeyNameIndex == KEY_NAME_INDEX_Enter &&

           !(mModifiers & (MODIFIER_ALT |

                           MODIFIER_META |

                           MODIFIER_OS |

                           MODIFIER_SHIFT));

  }

  virtual WidgetEvent* Duplicate() const override

  {

    MOZ_ASSERT(mClass == eKeyboardEventClass,

               "Duplicate() must be overridden by sub class");

    // Not copying widget, it is a weak reference.

    WidgetKeyboardEvent* result =

      new WidgetKeyboardEvent(false, mMessage, nullptr);

    result->AssignKeyEventData(*this, true);

    result->mEditCommandsForSingleLineEditor = mEditCommandsForSingleLineEditor;

    result->mEditCommandsForMultiLineEditor = mEditCommandsForMultiLineEditor;

    result->mEditCommandsForRichTextEditor = mEditCommandsForRichTextEditor;

    result->mFlags = mFlags;

    return result;

  }

  // OS translated Unicode chars which are used for accesskey and accelkey

  // handling. The handlers will try from first character to last character.

  nsTArray<AlternativeCharCode> mAlternativeCharCodes;

  // DOM KeyboardEvent.key only when mKeyNameIndex is KEY_NAME_INDEX_USE_STRING.

  nsString mKeyValue;

  // DOM KeyboardEvent.code only when mCodeNameIndex is

  // CODE_NAME_INDEX_USE_STRING.

  nsString mCodeValue;

#ifdef XP_MACOSX

  // Values given by a native NSEvent, for use with Cocoa NPAPI plugins.

  nsString mNativeCharacters;

  nsString mNativeCharactersIgnoringModifiers;

  // If this is non-empty, create a text event for plugins instead of a

  // keyboard event.

  nsString mPluginTextEventString;

#endif // #ifdef XP_MACOSX

  // OS-specific native event can optionally be preserved

  void* mNativeKeyEvent;

  // A DOM keyCode value or 0.  If a keypress event whose mCharCode is 0, this

  // should be 0.

  uint32_t mKeyCode;

  // If the instance is a keypress event of a printable key, this is a UTF-16

  // value of the key.  Otherwise, 0.  This value must not be a control

  // character when some modifiers are active.  Then, this value should be an

  // unmodified value except Shift and AltGr.

  uint32_t mCharCode;

  // mPseudoCharCode is valid only when mMessage is an eKeyDown event.

  // This stores mCharCode value of keypress event which is fired with same

  // key value and same modifier state.

  uint32_t mPseudoCharCode;

  // One of eKeyLocation*

  uint32_t mLocation;

  // Unique id associated with a keydown / keypress event. It's ok if this wraps

  // over long periods.

  uint32_t mUniqueId;

#ifdef XP_MACOSX

  // Values given by a native NSEvent, for use with Cocoa NPAPI plugins.

  uint32_t mNativeModifierFlags;

  uint16_t mNativeKeyCode;

#endif // #ifdef XP_MACOSX

  // DOM KeyboardEvent.key

  KeyNameIndex mKeyNameIndex;

  // DOM KeyboardEvent.code

  CodeNameIndex mCodeNameIndex;

  // Indicates whether the event is generated by auto repeat or not.

  // if this is keyup event, always false.

  bool mIsRepeat;

  // Indicates whether the event is generated during IME (or deadkey)

  // composition.  This is initialized by EventStateManager.  So, key event

  // dispatchers don't need to initialize this.

  bool mIsComposing;

  // Indicates whether the event is synthesized from Text Input Processor

  // or an actual event from nsAppShell.

  bool mIsSynthesizedByTIP;

  // Indicates whether the event is skippable in remote process.

  // Don't refer this member directly when you need to check this.

  // Use CanSkipInRemoteProcess() instead.

  bool mMaybeSkippableInRemoteProcess;

  bool CanSkipInRemoteProcess() const

  {

    // If this is a repeat event (i.e., generated by auto-repeat feature of

    // the platform), remove process may skip to handle it because of

    // performances reasons..  However, if it's caused by odd keyboard utils,

    // we should not ignore any key events even marked as repeated since

    // generated key sequence may be important to input proper text.  E.g.,

    // "SinhalaTamil IME" on Windows emulates dead key like input with

    // generating WM_KEYDOWN for VK_PACKET (inputting any Unicode characters

    // without keyboard layout information) and VK_BACK (Backspace) to remove

    // previous character(s) and those messages may be marked as "repeat" by

    // their bug.

    return mIsRepeat && mMaybeSkippableInRemoteProcess;

  }

  /**

   * Retrieves all edit commands from mWidget.  This shouldn't be called when

   * the instance is an untrusted event, doesn't have widget or in non-chrome

   * process.

   */

  void InitAllEditCommands();

  /**

   * Retrieves edit commands from mWidget only for aType.  This shouldn't be

   * called when the instance is an untrusted event or doesn't have widget.

   */

  void InitEditCommandsFor(nsIWidget::NativeKeyBindingsType aType);

  /**

   * PreventNativeKeyBindings() makes the instance to not cause any edit

   * actions even if it matches with a native key binding.

   */

  void PreventNativeKeyBindings()

  {

    mEditCommandsForSingleLineEditor.Clear();

    mEditCommandsForMultiLineEditor.Clear();

    mEditCommandsForRichTextEditor.Clear();

    mEditCommandsForSingleLineEditorInitialized = true;

    mEditCommandsForMultiLineEditorInitialized = true;

    mEditCommandsForRichTextEditorInitialized = true;

  }

  /**

   * EditCommandsConstRef() returns reference to edit commands for aType.

   */

  const nsTArray<CommandInt>&

    EditCommandsConstRef(nsIWidget::NativeKeyBindingsType aType) const

  {

    return const_cast<WidgetKeyboardEvent*>(this)->EditCommandsRef(aType);

  }

  /**

   * IsEditCommandsInitialized() returns true if edit commands for aType

   * was already initialized.  Otherwise, false.

   */

  bool IsEditCommandsInitialized(

         nsIWidget::NativeKeyBindingsType aType) const

  {

    return const_cast<WidgetKeyboardEvent*>(this)->

             IsEditCommandsInitializedRef(aType);

  }

#ifdef DEBUG

  /**

   * AreAllEditCommandsInitialized() returns true if edit commands for all

   * types were already initialized.  Otherwise, false.

   */

  bool AreAllEditCommandsInitialized() const

  {

    return mEditCommandsForSingleLineEditorInitialized &&

           mEditCommandsForMultiLineEditorInitialized &&

           mEditCommandsForRichTextEditorInitialized;

  }

#endif // #ifdef DEBUG

  /**

   * Execute edit commands for aType.

   *

   * @return        true if the caller should do nothing anymore.

   *                false, otherwise.

   */

  typedef void (*DoCommandCallback)(Command, void*);

  bool ExecuteEditCommands(nsIWidget::NativeKeyBindingsType aType,

                           DoCommandCallback aCallback,

                           void* aCallbackData);

  // If the key should cause keypress events, this returns true.

  // Otherwise, false.

  bool ShouldCauseKeypressEvents() const;

  // mCharCode value of non-eKeyPress events is always 0.  However, if

  // non-eKeyPress event has one or more alternative char code values,

  // its first item should be the mCharCode value of following eKeyPress event.

  // PseudoCharCode() returns mCharCode value for eKeyPress event,

  // the first alternative char code value of non-eKeyPress event or 0.

  uint32_t PseudoCharCode() const

  {

    return mMessage == eKeyPress ? mCharCode : mPseudoCharCode;

  }

  void SetCharCode(uint32_t aCharCode)

  {

    if (mMessage == eKeyPress) {

      mCharCode = aCharCode;

    } else {

      mPseudoCharCode = aCharCode;

    }

  }

  void GetDOMKeyName(nsAString& aKeyName)

  {

    if (mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {

      aKeyName = mKeyValue;

      return;

    }

    GetDOMKeyName(mKeyNameIndex, aKeyName);

  }

  void GetDOMCodeName(nsAString& aCodeName)

  {

    if (mCodeNameIndex == CODE_NAME_INDEX_USE_STRING) {

      aCodeName = mCodeValue;

      return;

    }

    GetDOMCodeName(mCodeNameIndex, aCodeName);

  }

  /**

   * GetFallbackKeyCodeOfPunctuationKey() returns a DOM keyCode value for

   * aCodeNameIndex.  This is keyCode value of the key when active keyboard

   * layout is ANSI (US), JIS or ABNT keyboard layout (the latter 2 layouts

   * are used only when ANSI doesn't have the key).  The result is useful

   * if the key doesn't produce ASCII character with active keyboard layout

   * nor with alternative ASCII capable keyboard layout.

   */

  static uint32_t

  GetFallbackKeyCodeOfPunctuationKey(CodeNameIndex aCodeNameIndex);

  bool IsModifierKeyEvent() const

  {

    return GetModifierForKeyName(mKeyNameIndex) != MODIFIER_NONE;

  }

  /**

   * Get the candidates for shortcut key.

   *

   * @param aCandidates [out] the candidate shortcut key combination list.

   *                          the first item is most preferred.

   */

  void GetShortcutKeyCandidates(ShortcutKeyCandidateArray& aCandidates) const;

  /**

   * Get the candidates for access key.

   *

   * @param aCandidates [out] the candidate access key list.

   *                          the first item is most preferred.

   */

  void GetAccessKeyCandidates(nsTArray<uint32_t>& aCandidates) const;

  /**

   * Check whether the modifiers match with chrome access key or

   * content access key.

   */

  bool ModifiersMatchWithAccessKey(AccessKeyType aType) const;

  /**

   * Return active modifiers which may match with access key.

   * For example, even if Alt is access key modifier, then, when Control,

   * CapseLock and NumLock are active, this returns only MODIFIER_CONTROL.

   */

  Modifiers ModifiersForAccessKeyMatching() const;

  /**

   * Return access key modifiers.

   */

  static Modifiers AccessKeyModifiers(AccessKeyType aType);

  static void Shutdown();

  /**

   * ComputeLocationFromCodeValue() returns one of .mLocation value

   * (eKeyLocation*) which is the most preferred value for the specified code

   * value.

   */

  static uint32_t ComputeLocationFromCodeValue(CodeNameIndex aCodeNameIndex);

  /**

   * ComputeKeyCodeFromKeyNameIndex() return a .mKeyCode value which can be

   * mapped from the specified key value.  Note that this returns 0 if the

   * key name index is KEY_NAME_INDEX_Unidentified or KEY_NAME_INDEX_USE_STRING.

   * This means that this method is useful only for non-printable keys.

   */

  static uint32_t ComputeKeyCodeFromKeyNameIndex(KeyNameIndex aKeyNameIndex);

  /**

   * GetModifierForKeyName() returns a value of Modifier which is activated

   * by the aKeyNameIndex.

   */

  static Modifier GetModifierForKeyName(KeyNameIndex aKeyNameIndex);

  /**

   * IsLockableModifier() returns true if aKeyNameIndex is a lockable modifier

   * key such as CapsLock and NumLock.

   */

  static bool IsLockableModifier(KeyNameIndex aKeyNameIndex);

  static void GetDOMKeyName(KeyNameIndex aKeyNameIndex,

                            nsAString& aKeyName);

  static void GetDOMCodeName(CodeNameIndex aCodeNameIndex,

                             nsAString& aCodeName);

  static KeyNameIndex GetKeyNameIndex(const nsAString& aKeyValue);

  static CodeNameIndex GetCodeNameIndex(const nsAString& aCodeValue);

  static const char* GetCommandStr(Command aCommand);

  void AssignKeyEventData(const WidgetKeyboardEvent& aEvent, bool aCopyTargets)

  {

    AssignInputEventData(aEvent, aCopyTargets);

    mKeyCode = aEvent.mKeyCode;

    mCharCode = aEvent.mCharCode;

    mPseudoCharCode = aEvent.mPseudoCharCode;

    mLocation = aEvent.mLocation;

    mAlternativeCharCodes = aEvent.mAlternativeCharCodes;

    mIsRepeat = aEvent.mIsRepeat;

    mIsComposing = aEvent.mIsComposing;

    mKeyNameIndex = aEvent.mKeyNameIndex;

    mCodeNameIndex = aEvent.mCodeNameIndex;

    mKeyValue = aEvent.mKeyValue;

    mCodeValue = aEvent.mCodeValue;

    // Don't copy mNativeKeyEvent because it may be referred after its instance

    // is destroyed.

    mNativeKeyEvent = nullptr;

    mUniqueId = aEvent.mUniqueId;

#ifdef XP_MACOSX

    mNativeKeyCode = aEvent.mNativeKeyCode;

    mNativeModifierFlags = aEvent.mNativeModifierFlags;

    mNativeCharacters.Assign(aEvent.mNativeCharacters);

    mNativeCharactersIgnoringModifiers.

      Assign(aEvent.mNativeCharactersIgnoringModifiers);

    mPluginTextEventString.Assign(aEvent.mPluginTextEventString);

#endif

    mIsSynthesizedByTIP = aEvent.mIsSynthesizedByTIP;

    mMaybeSkippableInRemoteProcess = aEvent.mMaybeSkippableInRemoteProcess;

    // Don't copy mEditCommandsFor*Editor because it may require a lot of

    // memory space.  For example, if the event is dispatched but grabbed by

    // a JS variable, they are not necessary anymore.

    mEditCommandsForSingleLineEditorInitialized =

      aEvent.mEditCommandsForSingleLineEditorInitialized;

    mEditCommandsForMultiLineEditorInitialized =

      aEvent.mEditCommandsForMultiLineEditorInitialized;

    mEditCommandsForRichTextEditorInitialized =

      aEvent.mEditCommandsForRichTextEditorInitialized;

  }

private:

  static const char16_t* const kKeyNames[];

  static const char16_t* const kCodeNames[];

  typedef nsDataHashtable<nsStringHashKey,

                          KeyNameIndex> KeyNameIndexHashtable;

  typedef nsDataHashtable<nsStringHashKey,

                          CodeNameIndex> CodeNameIndexHashtable;

  static KeyNameIndexHashtable* sKeyNameIndexHashtable;

  static CodeNameIndexHashtable* sCodeNameIndexHashtable;

  // mEditCommandsFor*Editor store edit commands.  This should be initialized

  // with InitEditCommandsFor().

  // XXX Ideally, this should be array of Command rather than CommandInt.

  //     However, ParamTraits isn't aware of enum array.

  nsTArray<CommandInt> mEditCommandsForSingleLineEditor;

  nsTArray<CommandInt> mEditCommandsForMultiLineEditor;

  nsTArray<CommandInt> mEditCommandsForRichTextEditor;

  nsTArray<CommandInt>& EditCommandsRef(nsIWidget::NativeKeyBindingsType aType)

  {

    switch (aType) {

      case nsIWidget::NativeKeyBindingsForSingleLineEditor:

        return mEditCommandsForSingleLineEditor;

      case nsIWidget::NativeKeyBindingsForMultiLineEditor:

        return mEditCommandsForMultiLineEditor;

      case nsIWidget::NativeKeyBindingsForRichTextEditor:

        return mEditCommandsForRichTextEditor;

      default:

        MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE(

          "Invalid native key binding type");

    }

  }

  // mEditCommandsFor*EditorInitialized are set to true when

  // InitEditCommandsFor() initializes edit commands for the type.

  bool mEditCommandsForSingleLineEditorInitialized;

  bool mEditCommandsForMultiLineEditorInitialized;

  bool mEditCommandsForRichTextEditorInitialized;

  bool& IsEditCommandsInitializedRef(nsIWidget::NativeKeyBindingsType aType)

  {

    switch (aType) {

      case nsIWidget::NativeKeyBindingsForSingleLineEditor:

        return mEditCommandsForSingleLineEditorInitialized;

      case nsIWidget::NativeKeyBindingsForMultiLineEditor:

        return mEditCommandsForMultiLineEditorInitialized;

      case nsIWidget::NativeKeyBindingsForRichTextEditor:

        return mEditCommandsForRichTextEditorInitialized;

      default:

        MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE(

          "Invalid native key binding type");

    }

  }

  static int32_t GenericAccessModifierKeyPref();

  static int32_t ChromeAccessModifierMaskPref();

  static int32_t ContentAccessModifierMaskPref();

};

/******************************************************************************

 * mozilla::WidgetCompositionEvent

 ******************************************************************************/

class WidgetCompositionEvent : public WidgetGUIEvent

{

private:

  friend class mozilla::dom::PBrowserParent;

  friend class mozilla::dom::PBrowserChild;

  WidgetCompositionEvent()

    : mOriginalMessage(eVoidEvent)

  {

  }

public:

  virtual WidgetCompositionEvent* AsCompositionEvent() override

  {

    return this;

  }

  WidgetCompositionEvent(bool aIsTrusted, EventMessage aMessage,

                         nsIWidget* aWidget)

    : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eCompositionEventClass)

    , mNativeIMEContext(aWidget)

    , mOriginalMessage(eVoidEvent)

  {

  }

  virtual WidgetEvent* Duplicate() const override

  {

    MOZ_ASSERT(mClass == eCompositionEventClass,

               "Duplicate() must be overridden by sub class");

    // Not copying widget, it is a weak reference.

    WidgetCompositionEvent* result =

      new WidgetCompositionEvent(false, mMessage, nullptr);

    result->AssignCompositionEventData(*this, true);

    result->mFlags = mFlags;

    return result;

  }

  // The composition string or the commit string.  If the instance is a

  // compositionstart event, this is initialized with selected text by

  // TextComposition automatically.

  nsString mData;

  RefPtr<TextRangeArray> mRanges;

  // mNativeIMEContext stores the native IME context which causes the

  // composition event.

  widget::NativeIMEContext mNativeIMEContext;

  // If the instance is a clone of another event, mOriginalMessage stores

  // the another event's mMessage.

  EventMessage mOriginalMessage;

  void AssignCompositionEventData(const WidgetCompositionEvent& aEvent,

                                  bool aCopyTargets)

  {

    AssignGUIEventData(aEvent, aCopyTargets);

    mData = aEvent.mData;

    mOriginalMessage = aEvent.mOriginalMessage;

    mRanges = aEvent.mRanges;

    // Currently, we don't need to copy the other members because they are

    // for internal use only (not available from JS).

  }

  bool IsComposing() const

  {

    return mRanges && mRanges->IsComposing();

  }

  uint32_t TargetClauseOffset() const

  {

    return mRanges ? mRanges->TargetClauseOffset() : 0;

  }

  uint32_t TargetClauseLength() const

  {

    uint32_t length = UINT32_MAX;

    if (mRanges) {

      length = mRanges->TargetClauseLength();

    }

    return length == UINT32_MAX ? mData.Length() : length;

  }

  uint32_t RangeCount() const

  {

    return mRanges ? mRanges->Length() : 0;

  }

  bool CausesDOMTextEvent() const

  {

    return mMessage == eCompositionChange ||

           mMessage == eCompositionCommit ||

           mMessage == eCompositionCommitAsIs;

  }

  bool CausesDOMCompositionEndEvent() const

  {

    return mMessage == eCompositionEnd ||

           mMessage == eCompositionCommit ||

           mMessage == eCompositionCommitAsIs;

  }

  bool IsFollowedByCompositionEnd() const

  {

    return IsFollowedByCompositionEnd(mOriginalMessage);

  }

  static bool IsFollowedByCompositionEnd(EventMessage aEventMessage)

  {

    return aEventMessage == eCompositionCommit ||

           aEventMessage == eCompositionCommitAsIs;

  }

};

/******************************************************************************

 * mozilla::WidgetQueryContentEvent

 ******************************************************************************/

class WidgetQueryContentEvent : public WidgetGUIEvent

{

private:

  friend class dom::PBrowserParent;

  friend class dom::PBrowserChild;

  WidgetQueryContentEvent()

    : mSucceeded(false)

    , mUseNativeLineBreak(true)

    , mWithFontRanges(false)

  {

    MOZ_CRASH("WidgetQueryContentEvent is created without proper arguments");

  }

public:

  virtual WidgetQueryContentEvent* AsQueryContentEvent() override

  {

    return this;

  }

  WidgetQueryContentEvent(bool aIsTrusted, EventMessage aMessage,

                          nsIWidget* aWidget)

    : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eQueryContentEventClass)

    , mSucceeded(false)

    , mUseNativeLineBreak(true)

    , mWithFontRanges(false)

  {

  }

  WidgetQueryContentEvent(EventMessage aMessage,

                          const WidgetQueryContentEvent& aOtherEvent)

    : WidgetGUIEvent(aOtherEvent.IsTrusted(), aMessage,

                     const_cast<nsIWidget*>(aOtherEvent.mWidget.get()),

                     eQueryContentEventClass)

    , mSucceeded(false)

    , mUseNativeLineBreak(aOtherEvent.mUseNativeLineBreak)

    , mWithFontRanges(false)

  {

  }

  virtual WidgetEvent* Duplicate() const override

  {

    // This event isn't an internal event of any DOM event.

    NS_ASSERTION(!IsAllowedToDispatchDOMEvent(),

      "WidgetQueryContentEvent needs to support Duplicate()");

    MOZ_CRASH("WidgetQueryContentEvent doesn't support Duplicate()");

  }

  struct Options final

  {

    bool mUseNativeLineBreak;

    bool mRelativeToInsertionPoint;

    explicit Options()

      : mUseNativeLineBreak(true)

      , mRelativeToInsertionPoint(false)

    {

    }

    explicit Options(const WidgetQueryContentEvent& aEvent)

      : mUseNativeLineBreak(aEvent.mUseNativeLineBreak)

      , mRelativeToInsertionPoint(aEvent.mInput.mRelativeToInsertionPoint)

    {

    }

  };

  void Init(const Options& aOptions)

  {

    mUseNativeLineBreak = aOptions.mUseNativeLineBreak;

    mInput.mRelativeToInsertionPoint = aOptions.mRelativeToInsertionPoint;

    MOZ_ASSERT(mInput.IsValidEventMessage(mMessage));

  }

  void InitForQueryTextContent(int64_t aOffset, uint32_t aLength,

                               const Options& aOptions = Options())

  {

    NS_ASSERTION(mMessage == eQueryTextContent,

                 "wrong initializer is called");

    mInput.mOffset = aOffset;

    mInput.mLength = aLength;

    Init(aOptions);

    MOZ_ASSERT(mInput.IsValidOffset());

  }

  void InitForQueryCaretRect(int64_t aOffset,

                             const Options& aOptions = Options())

  {

    NS_ASSERTION(mMessage == eQueryCaretRect,

                 "wrong initializer is called");

    mInput.mOffset = aOffset;

    Init(aOptions);

    MOZ_ASSERT(mInput.IsValidOffset());

  }

  void InitForQueryTextRect(int64_t aOffset, uint32_t aLength,

                            const Options& aOptions = Options())

  {

    NS_ASSERTION(mMessage == eQueryTextRect,

                 "wrong initializer is called");

    mInput.mOffset = aOffset;

    mInput.mLength = aLength;

    Init(aOptions);

    MOZ_ASSERT(mInput.IsValidOffset());

  }

  void InitForQuerySelectedText(SelectionType aSelectionType,

                                const Options& aOptions = Options())

  {

    MOZ_ASSERT(mMessage == eQuerySelectedText);

    MOZ_ASSERT(aSelectionType != SelectionType::eNone);

    mInput.mSelectionType = aSelectionType;

    Init(aOptions);

  }

  void InitForQueryDOMWidgetHittest(const mozilla::LayoutDeviceIntPoint& aPoint)

  {

    NS_ASSERTION(mMessage == eQueryDOMWidgetHittest,

                 "wrong initializer is called");

    mRefPoint = aPoint;

  }

  void InitForQueryTextRectArray(uint32_t aOffset, uint32_t aLength,

                                 const Options& aOptions = Options())

  {

    NS_ASSERTION(mMessage == eQueryTextRectArray,

                 "wrong initializer is called");

    mInput.mOffset = aOffset;

    mInput.mLength = aLength;

    Init(aOptions);

  }

  void RequestFontRanges()

  {

    NS_ASSERTION(mMessage == eQueryTextContent,

                 "not querying text content");

    mWithFontRanges = true;

  }

  uint32_t GetSelectionStart(void) const

  {

    NS_ASSERTION(mMessage == eQuerySelectedText,

                 "not querying selection");

    return mReply.mOffset + (mReply.mReversed ? mReply.mString.Length() : 0);

  }

  uint32_t GetSelectionEnd(void) const

  {

    NS_ASSERTION(mMessage == eQuerySelectedText,

                 "not querying selection");

    return mReply.mOffset + (mReply.mReversed ? 0 : mReply.mString.Length());

  }

  mozilla::WritingMode GetWritingMode(void) const

  {

    NS_ASSERTION(mMessage == eQuerySelectedText ||

                 mMessage == eQueryCaretRect ||

                 mMessage == eQueryTextRect,

                 "not querying selection or text rect");

    return mReply.mWritingMode;

  }

  bool mSucceeded;

  bool mUseNativeLineBreak;

  bool mWithFontRanges;

  struct Input final

  {

    uint32_t EndOffset() const

    {

      CheckedInt<uint32_t> endOffset =

        CheckedInt<uint32_t>(mOffset) + mLength;