path: root/widget/android/GeckoEditableSupport.cpp

/* -*- Mode: c++; c-basic-offset: 2; tab-width: 4; indent-tabs-mode: nil; -*-
 * vim: set sw=2 ts=4 expandtab:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "GeckoEditableSupport.h"

#include "AndroidRect.h"
#include "KeyEvent.h"
#include "PuppetWidget.h"
#include "nsIContent.h"
#include "nsITransferable.h"
#include "nsStringStream.h"

#include "mozilla/dom/ContentChild.h"
#include "mozilla/IMEStateManager.h"
#include "mozilla/java/GeckoEditableChildWrappers.h"
#include "mozilla/java/GeckoServiceChildProcessWrappers.h"
#include "mozilla/Logging.h"
#include "mozilla/MiscEvents.h"
#include "mozilla/Preferences.h"
#include "mozilla/StaticPrefs_intl.h"
#include "mozilla/TextComposition.h"
#include "mozilla/TextEventDispatcherListener.h"
#include "mozilla/TextEvents.h"
#include "mozilla/ToString.h"
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/widget/GeckoViewSupport.h"

#include <android/api-level.h>
#include <android/input.h>
#include <android/log.h>

#ifdef NIGHTLY_BUILD
static mozilla::LazyLogModule sGeckoEditableSupportLog("GeckoEditableSupport");
#  define ALOGIME(...) \
    MOZ_LOG(sGeckoEditableSupportLog, LogLevel::Debug, (__VA_ARGS__))
#else
#  define ALOGIME(args...) \
    do {                   \
    } while (0)
#endif

static uint32_t ConvertAndroidKeyCodeToDOMKeyCode(int32_t androidKeyCode) {
  // Special-case alphanumeric keycodes because they are most common.
  if (androidKeyCode >= AKEYCODE_A && androidKeyCode <= AKEYCODE_Z) {
    return androidKeyCode - AKEYCODE_A + NS_VK_A;
  }

  if (androidKeyCode >= AKEYCODE_0 && androidKeyCode <= AKEYCODE_9) {
    return androidKeyCode - AKEYCODE_0 + NS_VK_0;
  }

  switch (androidKeyCode) {
    // KEYCODE_UNKNOWN (0) ... KEYCODE_HOME (3)
    case AKEYCODE_BACK:
      return NS_VK_ESCAPE;
    // KEYCODE_CALL (5) ... KEYCODE_POUND (18)
    case AKEYCODE_DPAD_UP:
      return NS_VK_UP;
    case AKEYCODE_DPAD_DOWN:
      return NS_VK_DOWN;
    case AKEYCODE_DPAD_LEFT:
      return NS_VK_LEFT;
    case AKEYCODE_DPAD_RIGHT:
      return NS_VK_RIGHT;
    case AKEYCODE_DPAD_CENTER:
      return NS_VK_RETURN;
    case AKEYCODE_VOLUME_UP:
      return NS_VK_VOLUME_UP;
    case AKEYCODE_VOLUME_DOWN:
      return NS_VK_VOLUME_DOWN;
    // KEYCODE_VOLUME_POWER (26) ... KEYCODE_Z (54)
    case AKEYCODE_COMMA:
      return NS_VK_COMMA;
    case AKEYCODE_PERIOD:
      return NS_VK_PERIOD;
    case AKEYCODE_ALT_LEFT:
      return NS_VK_ALT;
    case AKEYCODE_ALT_RIGHT:
      return NS_VK_ALT;
    case AKEYCODE_SHIFT_LEFT:
      return NS_VK_SHIFT;
    case AKEYCODE_SHIFT_RIGHT:
      return NS_VK_SHIFT;
    case AKEYCODE_TAB:
      return NS_VK_TAB;
    case AKEYCODE_SPACE:
      return NS_VK_SPACE;
    // KEYCODE_SYM (63) ... KEYCODE_ENVELOPE (65)
    case AKEYCODE_ENTER:
      return NS_VK_RETURN;
    case AKEYCODE_DEL:
      return NS_VK_BACK;  // Backspace
    case AKEYCODE_GRAVE:
      return NS_VK_BACK_QUOTE;
    // KEYCODE_MINUS (69)
    case AKEYCODE_EQUALS:
      return NS_VK_EQUALS;
    case AKEYCODE_LEFT_BRACKET:
      return NS_VK_OPEN_BRACKET;
    case AKEYCODE_RIGHT_BRACKET:
      return NS_VK_CLOSE_BRACKET;
    case AKEYCODE_BACKSLASH:
      return NS_VK_BACK_SLASH;
    case AKEYCODE_SEMICOLON:
      return NS_VK_SEMICOLON;
    // KEYCODE_APOSTROPHE (75)
    case AKEYCODE_SLASH:
      return NS_VK_SLASH;
    // KEYCODE_AT (77) ... KEYCODE_MEDIA_FAST_FORWARD (90)
    case AKEYCODE_MUTE:
      return NS_VK_VOLUME_MUTE;
    case AKEYCODE_PAGE_UP:
      return NS_VK_PAGE_UP;
    case AKEYCODE_PAGE_DOWN:
      return NS_VK_PAGE_DOWN;
    // KEYCODE_PICTSYMBOLS (94) ... KEYCODE_BUTTON_MODE (110)
    case AKEYCODE_ESCAPE:
      return NS_VK_ESCAPE;
    case AKEYCODE_FORWARD_DEL:
      return NS_VK_DELETE;
    case AKEYCODE_CTRL_LEFT:
      return NS_VK_CONTROL;
    case AKEYCODE_CTRL_RIGHT:
      return NS_VK_CONTROL;
    case AKEYCODE_CAPS_LOCK:
      return NS_VK_CAPS_LOCK;
    case AKEYCODE_SCROLL_LOCK:
      return NS_VK_SCROLL_LOCK;
    // KEYCODE_META_LEFT (117) ... KEYCODE_FUNCTION (119)
    case AKEYCODE_SYSRQ:
      return NS_VK_PRINTSCREEN;
    case AKEYCODE_BREAK:
      return NS_VK_PAUSE;
    case AKEYCODE_MOVE_HOME:
      return NS_VK_HOME;
    case AKEYCODE_MOVE_END:
      return NS_VK_END;
    case AKEYCODE_INSERT:
      return NS_VK_INSERT;
    // KEYCODE_FORWARD (125) ... KEYCODE_MEDIA_RECORD (130)
    case AKEYCODE_F1:
      return NS_VK_F1;
    case AKEYCODE_F2:
      return NS_VK_F2;
    case AKEYCODE_F3:
      return NS_VK_F3;
    case AKEYCODE_F4:
      return NS_VK_F4;
    case AKEYCODE_F5:
      return NS_VK_F5;
    case AKEYCODE_F6:
      return NS_VK_F6;
    case AKEYCODE_F7:
      return NS_VK_F7;
    case AKEYCODE_F8:
      return NS_VK_F8;
    case AKEYCODE_F9:
      return NS_VK_F9;
    case AKEYCODE_F10:
      return NS_VK_F10;
    case AKEYCODE_F11:
      return NS_VK_F11;
    case AKEYCODE_F12:
      return NS_VK_F12;
    case AKEYCODE_NUM_LOCK:
      return NS_VK_NUM_LOCK;
    case AKEYCODE_NUMPAD_0:
      return NS_VK_NUMPAD0;
    case AKEYCODE_NUMPAD_1:
      return NS_VK_NUMPAD1;
    case AKEYCODE_NUMPAD_2:
      return NS_VK_NUMPAD2;
    case AKEYCODE_NUMPAD_3:
      return NS_VK_NUMPAD3;
    case AKEYCODE_NUMPAD_4:
      return NS_VK_NUMPAD4;
    case AKEYCODE_NUMPAD_5:
      return NS_VK_NUMPAD5;
    case AKEYCODE_NUMPAD_6:
      return NS_VK_NUMPAD6;
    case AKEYCODE_NUMPAD_7:
      return NS_VK_NUMPAD7;
    case AKEYCODE_NUMPAD_8:
      return NS_VK_NUMPAD8;
    case AKEYCODE_NUMPAD_9:
      return NS_VK_NUMPAD9;
    case AKEYCODE_NUMPAD_DIVIDE:
      return NS_VK_DIVIDE;
    case AKEYCODE_NUMPAD_MULTIPLY:
      return NS_VK_MULTIPLY;
    case AKEYCODE_NUMPAD_SUBTRACT:
      return NS_VK_SUBTRACT;
    case AKEYCODE_NUMPAD_ADD:
      return NS_VK_ADD;
    case AKEYCODE_NUMPAD_DOT:
      return NS_VK_DECIMAL;
    case AKEYCODE_NUMPAD_COMMA:
      return NS_VK_SEPARATOR;
    case AKEYCODE_NUMPAD_ENTER:
      return NS_VK_RETURN;
    case AKEYCODE_NUMPAD_EQUALS:
      return NS_VK_EQUALS;
    // KEYCODE_NUMPAD_LEFT_PAREN (162) ... KEYCODE_CALCULATOR (210)

    // Needs to confirm the behavior.  If the key switches the open state
    // of Japanese IME (or switches input character between Hiragana and
    // Roman numeric characters), then, it might be better to use
    // NS_VK_KANJI which is used for Alt+Zenkaku/Hankaku key on Windows.
    case AKEYCODE_ZENKAKU_HANKAKU:
      return 0;
    case AKEYCODE_EISU:
      return NS_VK_EISU;
    case AKEYCODE_MUHENKAN:
      return NS_VK_NONCONVERT;
    case AKEYCODE_HENKAN:
      return NS_VK_CONVERT;
    case AKEYCODE_KATAKANA_HIRAGANA:
      return 0;
    case AKEYCODE_YEN:
      return NS_VK_BACK_SLASH;  // Same as other platforms.
    case AKEYCODE_RO:
      return NS_VK_BACK_SLASH;  // Same as other platforms.
    case AKEYCODE_KANA:
      return NS_VK_KANA;
    case AKEYCODE_ASSIST:
      return NS_VK_HELP;

    // the A key is the action key for gamepad devices.
    case AKEYCODE_BUTTON_A:
      return NS_VK_RETURN;

    default:
      ALOG(
          "ConvertAndroidKeyCodeToDOMKeyCode: "
          "No DOM keycode for Android keycode %d",
          int(androidKeyCode));
      return 0;
  }
}

static KeyNameIndex ConvertAndroidKeyCodeToKeyNameIndex(
    int32_t keyCode, int32_t action, int32_t domPrintableKeyValue) {
  // Special-case alphanumeric keycodes because they are most common.
  if (keyCode >= AKEYCODE_A && keyCode <= AKEYCODE_Z) {
    return KEY_NAME_INDEX_USE_STRING;
  }

  if (keyCode >= AKEYCODE_0 && keyCode <= AKEYCODE_9) {
    return KEY_NAME_INDEX_USE_STRING;
  }

  switch (keyCode) {
#define NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX(aNativeKey, aKeyNameIndex) \
  case aNativeKey:                                                     \
    return aKeyNameIndex;

#include "NativeKeyToDOMKeyName.h"

#undef NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX

    // KEYCODE_0 (7) ... KEYCODE_9 (16)
    case AKEYCODE_STAR:   // '*' key
    case AKEYCODE_POUND:  // '#' key

      // KEYCODE_A (29) ... KEYCODE_Z (54)

    case AKEYCODE_COMMA:   // ',' key
    case AKEYCODE_PERIOD:  // '.' key
    case AKEYCODE_SPACE:
    case AKEYCODE_GRAVE:          // '`' key
    case AKEYCODE_MINUS:          // '-' key
    case AKEYCODE_EQUALS:         // '=' key
    case AKEYCODE_LEFT_BRACKET:   // '[' key
    case AKEYCODE_RIGHT_BRACKET:  // ']' key
    case AKEYCODE_BACKSLASH:      // '\' key
    case AKEYCODE_SEMICOLON:      // ';' key
    case AKEYCODE_APOSTROPHE:     // ''' key
    case AKEYCODE_SLASH:          // '/' key
    case AKEYCODE_AT:             // '@' key
    case AKEYCODE_PLUS:           // '+' key

    case AKEYCODE_NUMPAD_0:
    case AKEYCODE_NUMPAD_1:
    case AKEYCODE_NUMPAD_2:
    case AKEYCODE_NUMPAD_3:
    case AKEYCODE_NUMPAD_4:
    case AKEYCODE_NUMPAD_5:
    case AKEYCODE_NUMPAD_6:
    case AKEYCODE_NUMPAD_7:
    case AKEYCODE_NUMPAD_8:
    case AKEYCODE_NUMPAD_9:
    case AKEYCODE_NUMPAD_DIVIDE:
    case AKEYCODE_NUMPAD_MULTIPLY:
    case AKEYCODE_NUMPAD_SUBTRACT:
    case AKEYCODE_NUMPAD_ADD:
    case AKEYCODE_NUMPAD_DOT:
    case AKEYCODE_NUMPAD_COMMA:
    case AKEYCODE_NUMPAD_EQUALS:
    case AKEYCODE_NUMPAD_LEFT_PAREN:
    case AKEYCODE_NUMPAD_RIGHT_PAREN:

    case AKEYCODE_YEN:  // yen sign key
    case AKEYCODE_RO:   // Japanese Ro key
      return KEY_NAME_INDEX_USE_STRING;

    case AKEYCODE_NUM:  // XXX Not sure
    case AKEYCODE_PICTSYMBOLS:

    case AKEYCODE_BUTTON_A:
    case AKEYCODE_BUTTON_B:
    case AKEYCODE_BUTTON_C:
    case AKEYCODE_BUTTON_X:
    case AKEYCODE_BUTTON_Y:
    case AKEYCODE_BUTTON_Z:
    case AKEYCODE_BUTTON_L1:
    case AKEYCODE_BUTTON_R1:
    case AKEYCODE_BUTTON_L2:
    case AKEYCODE_BUTTON_R2:
    case AKEYCODE_BUTTON_THUMBL:
    case AKEYCODE_BUTTON_THUMBR:
    case AKEYCODE_BUTTON_START:
    case AKEYCODE_BUTTON_SELECT:
    case AKEYCODE_BUTTON_MODE:

    case AKEYCODE_MEDIA_CLOSE:

    case AKEYCODE_BUTTON_1:
    case AKEYCODE_BUTTON_2:
    case AKEYCODE_BUTTON_3:
    case AKEYCODE_BUTTON_4:
    case AKEYCODE_BUTTON_5:
    case AKEYCODE_BUTTON_6:
    case AKEYCODE_BUTTON_7:
    case AKEYCODE_BUTTON_8:
    case AKEYCODE_BUTTON_9:
    case AKEYCODE_BUTTON_10:
    case AKEYCODE_BUTTON_11:
    case AKEYCODE_BUTTON_12:
    case AKEYCODE_BUTTON_13:
    case AKEYCODE_BUTTON_14:
    case AKEYCODE_BUTTON_15:
    case AKEYCODE_BUTTON_16:
      return KEY_NAME_INDEX_Unidentified;

    case AKEYCODE_UNKNOWN:
      MOZ_ASSERT(action != AKEY_EVENT_ACTION_MULTIPLE,
                 "Don't call this when action is AKEY_EVENT_ACTION_MULTIPLE!");
      // It's actually an unknown key if the action isn't ACTION_MULTIPLE.
      // However, it might cause text input.  So, let's check the value.
      return domPrintableKeyValue ? KEY_NAME_INDEX_USE_STRING
                                  : KEY_NAME_INDEX_Unidentified;

    default:
      ALOG(
          "ConvertAndroidKeyCodeToKeyNameIndex: "
          "No DOM key name index for Android keycode %d",
          keyCode);
      return KEY_NAME_INDEX_Unidentified;
  }
}

static CodeNameIndex ConvertAndroidScanCodeToCodeNameIndex(int32_t scanCode) {
  switch (scanCode) {
#define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, aCodeNameIndex) \
  case aNativeKey:                                                       \
    return aCodeNameIndex;

#include "NativeKeyToDOMCodeName.h"

#undef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX

    default:
      return CODE_NAME_INDEX_UNKNOWN;
  }
}

static void InitKeyEvent(WidgetKeyboardEvent& aEvent, int32_t aAction,
                         int32_t aKeyCode, int32_t aScanCode,
                         int32_t aMetaState, int64_t aTime,
                         int32_t aDomPrintableKeyValue, int32_t aRepeatCount,
                         int32_t aFlags) {
  const uint32_t domKeyCode = ConvertAndroidKeyCodeToDOMKeyCode(aKeyCode);

  aEvent.mModifiers = nsWindow::GetModifiers(aMetaState);
  aEvent.mKeyCode = domKeyCode;

  aEvent.mIsRepeat =
      (aEvent.mMessage == eKeyDown || aEvent.mMessage == eKeyPress) &&
      ((aFlags & java::sdk::KeyEvent::FLAG_LONG_PRESS) || aRepeatCount);

  aEvent.mKeyNameIndex = ConvertAndroidKeyCodeToKeyNameIndex(
      aKeyCode, aAction, aDomPrintableKeyValue);
  aEvent.mCodeNameIndex = ConvertAndroidScanCodeToCodeNameIndex(aScanCode);

  if (aEvent.mKeyNameIndex == KEY_NAME_INDEX_USE_STRING &&
      aDomPrintableKeyValue) {
    aEvent.mKeyValue = char16_t(aDomPrintableKeyValue);
  }

  aEvent.mLocation =
      WidgetKeyboardEvent::ComputeLocationFromCodeValue(aEvent.mCodeNameIndex);
  aEvent.mTimeStamp = nsWindow::GetEventTimeStamp(aTime);
}

static nscolor ConvertAndroidColor(uint32_t aArgb) {
  return NS_RGBA((aArgb & 0x00ff0000) >> 16, (aArgb & 0x0000ff00) >> 8,
                 (aArgb & 0x000000ff), (aArgb & 0xff000000) >> 24);
}

static jni::ObjectArray::LocalRef ConvertRectArrayToJavaRectFArray(
    const nsTArray<LayoutDeviceIntRect>& aRects) {
  const size_t length = aRects.Length();
  auto rects = jni::ObjectArray::New<java::sdk::RectF>(length);

  for (size_t i = 0; i < length; i++) {
    const LayoutDeviceIntRect& tmp = aRects[i];

    auto rect = java::sdk::RectF::New(tmp.x, tmp.y, tmp.XMost(), tmp.YMost());
    rects->SetElement(i, rect);
  }
  return rects;
}

namespace mozilla {
namespace widget {

NS_IMPL_ISUPPORTS(GeckoEditableSupport, TextEventDispatcherListener,
                  nsISupportsWeakReference)

// This is the blocker helper class whether disposing GeckoEditableChild now.
// During JNI call from GeckoEditableChild, we shouldn't dispose it.
class MOZ_RAII AutoGeckoEditableBlocker final {
 public:
  explicit AutoGeckoEditableBlocker(GeckoEditableSupport* aGeckoEditableSupport)
      : mGeckoEditable(aGeckoEditableSupport) {
    mGeckoEditable->AddBlocker();
  }
  ~AutoGeckoEditableBlocker() { mGeckoEditable->ReleaseBlocker(); }

 private:
  RefPtr<GeckoEditableSupport> mGeckoEditable;
};

RefPtr<TextComposition> GeckoEditableSupport::GetComposition() const {
  nsCOMPtr<nsIWidget> widget = GetWidget();
  return widget ? IMEStateManager::GetTextCompositionFor(widget) : nullptr;
}

bool GeckoEditableSupport::RemoveComposition(RemoveCompositionFlag aFlag) {
  if (!mDispatcher || !mDispatcher->IsComposing()) {
    return false;
  }

  nsEventStatus status = nsEventStatus_eIgnore;

  NS_ENSURE_SUCCESS(BeginInputTransaction(mDispatcher), false);
  mDispatcher->CommitComposition(
      status, aFlag == CANCEL_IME_COMPOSITION ? &EmptyString() : nullptr);
  return true;
}

void GeckoEditableSupport::OnKeyEvent(int32_t aAction, int32_t aKeyCode,
                                      int32_t aScanCode, int32_t aMetaState,
                                      int32_t aKeyPressMetaState, int64_t aTime,
                                      int32_t aDomPrintableKeyValue,
                                      int32_t aRepeatCount, int32_t aFlags,
                                      bool aIsSynthesizedImeKey,
                                      jni::Object::Param aOriginalEvent) {
  AutoGeckoEditableBlocker blocker(this);

  nsCOMPtr<nsIWidget> widget = GetWidget();
  RefPtr<TextEventDispatcher> dispatcher =
      mDispatcher ? mDispatcher.get()
      : widget    ? widget->GetTextEventDispatcher()
                  : nullptr;
  NS_ENSURE_TRUE_VOID(dispatcher && widget);

  if (!aIsSynthesizedImeKey) {
    if (nsWindow* window = GetNsWindow()) {
      window->UserActivity();
    }
  } else if (aIsSynthesizedImeKey && mIMEMaskEventsCount > 0) {
    // Don't synthesize editor keys when not focused.
    return;
  }

  EventMessage msg;
  if (aAction == java::sdk::KeyEvent::ACTION_DOWN) {
    msg = eKeyDown;
  } else if (aAction == java::sdk::KeyEvent::ACTION_UP) {
    msg = eKeyUp;
  } else if (aAction == java::sdk::KeyEvent::ACTION_MULTIPLE) {
    // Keys with multiple action are handled in Java,
    // and we should never see one here
    MOZ_CRASH("Cannot handle key with multiple action");
  } else {
    NS_WARNING("Unknown key action event");
    return;
  }

  nsEventStatus status = nsEventStatus_eIgnore;
  WidgetKeyboardEvent event(true, msg, widget);
  InitKeyEvent(event, aAction, aKeyCode, aScanCode, aMetaState, aTime,
               aDomPrintableKeyValue, aRepeatCount, aFlags);

  if (nsIWidget::UsePuppetWidgets()) {
    // Don't use native key bindings.
    event.PreventNativeKeyBindings();
  }

  if (aIsSynthesizedImeKey) {
    // Keys synthesized by Java IME code are saved in the mIMEKeyEvents
    // array until the next IME_REPLACE_TEXT event, at which point
    // these keys are dispatched in sequence.
    mIMEKeyEvents.AppendElement(UniquePtr<WidgetEvent>(event.Duplicate()));
  } else {
    NS_ENSURE_SUCCESS_VOID(BeginInputTransaction(dispatcher));
    dispatcher->DispatchKeyboardEvent(msg, event, status);
    if (widget->Destroyed() || status == nsEventStatus_eConsumeNoDefault) {
      // Skip default processing.
      return;
    }
    mEditable->OnDefaultKeyEvent(aOriginalEvent);
  }

  // Only send keypress after keydown.
  if (msg != eKeyDown) {
    return;
  }

  WidgetKeyboardEvent pressEvent(true, eKeyPress, widget);
  InitKeyEvent(pressEvent, aAction, aKeyCode, aScanCode, aKeyPressMetaState,
               aTime, aDomPrintableKeyValue, aRepeatCount, aFlags);

  if (nsIWidget::UsePuppetWidgets()) {
    // Don't use native key bindings.
    pressEvent.PreventNativeKeyBindings();
  }

  if (aIsSynthesizedImeKey) {
    mIMEKeyEvents.AppendElement(UniquePtr<WidgetEvent>(pressEvent.Duplicate()));
  } else {
    dispatcher->MaybeDispatchKeypressEvents(pressEvent, status);
  }
}

/*
 * Send dummy key events for pages that are unaware of input events,
 * to provide web compatibility for pages that depend on key events.
 */
void GeckoEditableSupport::SendIMEDummyKeyEvent(nsIWidget* aWidget,
                                                EventMessage msg) {
  AutoGeckoEditableBlocker blocker(this);

  nsEventStatus status = nsEventStatus_eIgnore;
  MOZ_ASSERT(mDispatcher);

  WidgetKeyboardEvent event(true, msg, aWidget);
  // TODO: If we can know scan code of the key event which caused replacing
  //       composition string, we should set mCodeNameIndex here.  Then,
  //       we should rename this method because it becomes not a "dummy"
  //       keyboard event.
  event.mKeyCode = NS_VK_PROCESSKEY;
  event.mKeyNameIndex = KEY_NAME_INDEX_Process;
  // KeyboardEvents marked as "processed by IME" shouldn't cause any edit
  // actions.  So, we should set their native key binding to none before
  // dispatch to avoid crash on PuppetWidget and avoid running redundant
  // path to look for native key bindings.
  if (nsIWidget::UsePuppetWidgets()) {
    event.PreventNativeKeyBindings();
  }
  NS_ENSURE_SUCCESS_VOID(BeginInputTransaction(mDispatcher));
  mDispatcher->DispatchKeyboardEvent(msg, event, status);
}

void GeckoEditableSupport::AddIMETextChange(
    const IMENotification::TextChangeDataBase& aChange) {
  mIMEPendingTextChange.MergeWith(aChange);

  // We may not be in the middle of flushing,
  // in which case this flag is meaningless.
  mIMETextChangedDuringFlush = true;
}

void GeckoEditableSupport::PostFlushIMEChanges() {
  if (mIMEPendingTextChange.IsValid() || mIMESelectionChanged) {
    // Already posted
    return;
  }

  RefPtr<GeckoEditableSupport> self(this);

  nsAppShell::PostEvent([this, self] {
    nsCOMPtr<nsIWidget> widget = GetWidget();
    if (widget && !widget->Destroyed()) {
      FlushIMEChanges();
    }
  });
}

void GeckoEditableSupport::FlushIMEChanges(FlushChangesFlag aFlags) {
  // Only send change notifications if we are *not* masking events,
  // i.e. if we have a focused editor,
  NS_ENSURE_TRUE_VOID(!mIMEMaskEventsCount);

  if (mIMEDelaySynchronizeReply && mIMEActiveCompositionCount > 0) {
    // We are still expecting more composition events to be handled. Once
    // that happens, FlushIMEChanges will be called again.
    return;
  }

  nsCOMPtr<nsIWidget> widget = GetWidget();
  NS_ENSURE_TRUE_VOID(widget);

  struct TextRecord {
    TextRecord() : start(-1), oldEnd(-1), newEnd(-1) {}

    bool IsValid() const { return start >= 0; }

    nsString text;
    int32_t start;
    int32_t oldEnd;
    int32_t newEnd;
  };
  TextRecord textTransaction;

  nsEventStatus status = nsEventStatus_eIgnore;
  bool causedOnlyByComposition = mIMEPendingTextChange.IsValid() &&
                                 mIMEPendingTextChange.mCausedOnlyByComposition;
  mIMETextChangedDuringFlush = false;

  auto shouldAbort = [=](bool aForce) -> bool {
    if (!aForce && !mIMETextChangedDuringFlush) {
      return false;
    }
    // A query event could have triggered more text changes to come in, as
    // indicated by our flag. If that happens, try flushing IME changes
    // again.
    if (aFlags == FLUSH_FLAG_NONE) {
      FlushIMEChanges(FLUSH_FLAG_RETRY);
    } else {
      // Don't retry if already retrying, to avoid infinite loops.
      __android_log_print(ANDROID_LOG_WARN, "GeckoEditableSupport",
                          "Already retrying IME flush");
    }
    return true;
  };

  if (mIMEPendingTextChange.IsValid() &&
      (mIMEPendingTextChange.mStartOffset !=
           mIMEPendingTextChange.mRemovedEndOffset ||
       mIMEPendingTextChange.mStartOffset !=
           mIMEPendingTextChange.mAddedEndOffset)) {
    WidgetQueryContentEvent queryTextContentEvent(true, eQueryTextContent,
                                                  widget);

    if (mIMEPendingTextChange.mAddedEndOffset !=
        mIMEPendingTextChange.mStartOffset) {
      queryTextContentEvent.InitForQueryTextContent(
          mIMEPendingTextChange.mStartOffset,
          mIMEPendingTextChange.mAddedEndOffset -
              mIMEPendingTextChange.mStartOffset);
      widget->DispatchEvent(&queryTextContentEvent, status);

      if (shouldAbort(NS_WARN_IF(queryTextContentEvent.Failed()))) {
        return;
      }

      textTransaction.text = queryTextContentEvent.mReply->DataRef();
    }

    textTransaction.start =
        static_cast<int32_t>(mIMEPendingTextChange.mStartOffset);
    textTransaction.oldEnd =
        static_cast<int32_t>(mIMEPendingTextChange.mRemovedEndOffset);
    textTransaction.newEnd =
        static_cast<int32_t>(mIMEPendingTextChange.mAddedEndOffset);
  }

  int32_t selStart = -1;
  int32_t selEnd = -1;

  if (mIMESelectionChanged) {
    if (mCachedSelection.IsValid()) {
      selStart = mCachedSelection.mStartOffset;
      selEnd = mCachedSelection.mEndOffset;
    } else {
      // XXX Unfortunately we don't know current selection via selection
      //     change notification.
      //     eQuerySelectedText might be newer data than text change data.
      //     It means that GeckoEditableChild.onSelectionChange may throw
      //     IllegalArgumentException since we don't merge with newer text
      //     change.
      WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
                                                     widget);
      widget->DispatchEvent(&querySelectedTextEvent, status);

      if (shouldAbort(
              NS_WARN_IF(querySelectedTextEvent.DidNotFindSelection()))) {
        return;
      }

      selStart =
          static_cast<int32_t>(querySelectedTextEvent.mReply->AnchorOffset());
      selEnd =
          static_cast<int32_t>(querySelectedTextEvent.mReply->FocusOffset());
    }

    if (aFlags == FLUSH_FLAG_RECOVER && textTransaction.IsValid()) {
      // Sometimes we get out-of-bounds selection during recovery.
      // Limit the offsets so we don't crash.
      const int32_t end = textTransaction.start + textTransaction.text.Length();
      selStart = std::min(selStart, end);
      selEnd = std::min(selEnd, end);
    }
  }

  JNIEnv* const env = jni::GetGeckoThreadEnv();
  auto flushOnException = [=]() -> bool {
    if (!env->ExceptionCheck()) {
      return false;
    }
    if (aFlags != FLUSH_FLAG_RECOVER) {
      // First time seeing an exception; try flushing text.
      env->ExceptionClear();
      __android_log_print(ANDROID_LOG_WARN, "GeckoEditableSupport",
                          "Recovering from IME exception");
      FlushIMEText(FLUSH_FLAG_RECOVER);
    } else {
      // Give up because we've already tried.
#ifdef RELEASE_OR_BETA
      env->ExceptionClear();
#else
      MOZ_CATCH_JNI_EXCEPTION(env);
#endif
    }
    return true;
  };

  // Commit the text change and selection change transaction.
  mIMEPendingTextChange.Clear();

  if (textTransaction.IsValid()) {
    mEditable->OnTextChange(textTransaction.text, textTransaction.start,
                            textTransaction.oldEnd, textTransaction.newEnd,
                            causedOnlyByComposition);
    if (flushOnException()) {
      return;
    }
  }

  while (mIMEDelaySynchronizeReply && mIMEActiveSynchronizeCount) {
    mIMEActiveSynchronizeCount--;
    mEditable->NotifyIME(EditableListener::NOTIFY_IME_REPLY_EVENT);
  }
  mIMEDelaySynchronizeReply = false;
  mIMEActiveSynchronizeCount = 0;
  mIMEActiveCompositionCount = 0;

  if (mIMESelectionChanged) {
    mIMESelectionChanged = false;
    if (mDispatcher) {
      // mCausedOnlyByComposition may be true on committing text.
      // So even if true, there is no composition.
      causedOnlyByComposition &= mDispatcher->IsComposing();
    }
    mEditable->OnSelectionChange(selStart, selEnd, causedOnlyByComposition);
    flushOnException();
  }
}

void GeckoEditableSupport::FlushIMEText(FlushChangesFlag aFlags) {
  NS_WARNING_ASSERTION(
      !mIMEDelaySynchronizeReply || !mIMEActiveCompositionCount,
      "Cannot synchronize Java text with Gecko text");

  // Notify Java of the newly focused content
  mIMEPendingTextChange.Clear();
  mIMESelectionChanged = true;

  // Use 'INT32_MAX / 2' here because subsequent text changes might combine
  // with this text change, and overflow might occur if we just use
  // INT32_MAX.
  IMENotification notification(NOTIFY_IME_OF_TEXT_CHANGE);
  notification.mTextChangeData.mStartOffset = 0;
  notification.mTextChangeData.mRemovedEndOffset = INT32_MAX / 2;
  notification.mTextChangeData.mAddedEndOffset = INT32_MAX / 2;
  NotifyIME(mDispatcher, notification);

  FlushIMEChanges(aFlags);
}

void GeckoEditableSupport::UpdateCompositionRects() {
  nsCOMPtr<nsIWidget> widget = GetWidget();
  RefPtr<TextComposition> composition(GetComposition());
  NS_ENSURE_TRUE_VOID(mDispatcher && widget);

  jni::ObjectArray::LocalRef rects;
  if (composition) {
    nsEventStatus status = nsEventStatus_eIgnore;
    uint32_t offset = composition->NativeOffsetOfStartComposition();
    WidgetQueryContentEvent queryTextRectsEvent(true, eQueryTextRectArray,
                                                widget);
    queryTextRectsEvent.InitForQueryTextRectArray(
        offset, composition->String().Length());
    widget->DispatchEvent(&queryTextRectsEvent, status);
    rects = ConvertRectArrayToJavaRectFArray(
        queryTextRectsEvent.Succeeded()
            ? queryTextRectsEvent.mReply->mRectArray
            : CopyableTArray<mozilla::LayoutDeviceIntRect>());
  } else {
    rects = ConvertRectArrayToJavaRectFArray(
        CopyableTArray<mozilla::LayoutDeviceIntRect>());
  }

  WidgetQueryContentEvent queryCaretRectEvent(true, eQueryCaretRect, widget);
  WidgetQueryContentEvent::Options options;
  options.mRelativeToInsertionPoint = true;
  queryCaretRectEvent.InitForQueryCaretRect(0, options);

  nsEventStatus status = nsEventStatus_eIgnore;
  widget->DispatchEvent(&queryCaretRectEvent, status);
  auto caretRect =
      queryCaretRectEvent.Succeeded()
          ? java::sdk::RectF::New(queryCaretRectEvent.mReply->mRect.x,
                                  queryCaretRectEvent.mReply->mRect.y,
                                  queryCaretRectEvent.mReply->mRect.XMost(),
                                  queryCaretRectEvent.mReply->mRect.YMost())
          : java::sdk::RectF::New();

  mEditable->UpdateCompositionRects(rects, caretRect);
}

void GeckoEditableSupport::OnImeSynchronize() {
  AutoGeckoEditableBlocker blocker(this);

  if (mIMEDelaySynchronizeReply) {
    // If we are waiting for other events to reply,
    // queue this reply as well.
    mIMEActiveSynchronizeCount++;
    return;
  }
  if (!mIMEMaskEventsCount) {
    FlushIMEChanges();
  }
  mEditable->NotifyIME(EditableListener::NOTIFY_IME_REPLY_EVENT);
}

void GeckoEditableSupport::OnImeReplaceText(int32_t aStart, int32_t aEnd,
                                            jni::String::Param aText) {
  AutoGeckoEditableBlocker blocker(this);

  if (DoReplaceText(aStart, aEnd, aText)) {
    mIMEDelaySynchronizeReply = true;
  }

  OnImeSynchronize();
}

bool GeckoEditableSupport::DoReplaceText(int32_t aStart, int32_t aEnd,
                                         jni::String::Param aText) {
  ALOGIME("IME: IME_REPLACE_TEXT: text=\"%s\"",
          NS_ConvertUTF16toUTF8(aText->ToString()).get());

  // Return true if processed and we should reply to the OnImeReplaceText
  // event later. Return false if _not_ processed and we should reply to the
  // OnImeReplaceText event now.

  if (mIMEMaskEventsCount > 0) {
    // Not focused; still reply to events, but don't do anything else.
    return false;
  }

  if (nsWindow* window = GetNsWindow()) {
    window->UserActivity();
  }

  /*
      Replace text in Gecko thread from aStart to aEnd with the string text.
  */
  nsCOMPtr<nsIWidget> widget = GetWidget();
  NS_ENSURE_TRUE(mDispatcher && widget, false);
  NS_ENSURE_SUCCESS(BeginInputTransaction(mDispatcher), false);

  RefPtr<TextComposition> composition(GetComposition());
  MOZ_ASSERT(!composition || !composition->IsEditorHandlingEvent());

  nsString string(aText->ToString());
  const bool composing = !mIMERanges->IsEmpty();
  nsEventStatus status = nsEventStatus_eIgnore;
  bool textChanged = composing;
  // Whether deleting content before setting or committing composition text.
  bool performDeletion = false;
  // Dispatch composition start to set current composition.
  bool needDispatchCompositionStart = false;

  if (!mIMEKeyEvents.IsEmpty() || !composition || !mDispatcher->IsComposing() ||
      uint32_t(aStart) != composition->NativeOffsetOfStartComposition() ||
      uint32_t(aEnd) != composition->NativeOffsetOfStartComposition() +
                            composition->String().Length()) {
    // Only start a new composition if we have key events,
    // if we don't have an existing composition, or
    // the replaced text does not match our composition.
    textChanged |= RemoveComposition();

#ifdef NIGHTLY_BUILD
    {
      nsEventStatus status = nsEventStatus_eIgnore;
      WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
                                                     widget);
      widget->DispatchEvent(&querySelectedTextEvent, status);
      if (querySelectedTextEvent.Succeeded()) {
        ALOGIME(
            "IME: Current selection: %s",
            ToString(querySelectedTextEvent.mReply->mOffsetAndData).c_str());
      }
    }
#endif

    // If aStart or aEnd is negative value, we use current selection instead
    // of updating the selection.
    if (aStart >= 0 && aEnd >= 0) {
      // Use text selection to set target position(s) for
      // insert, or replace, of text.
      WidgetSelectionEvent event(true, eSetSelection, widget);
      event.mOffset = uint32_t(aStart);
      event.mLength = uint32_t(aEnd - aStart);
      event.mExpandToClusterBoundary = false;
      event.mReason = nsISelectionListener::IME_REASON;
      widget->DispatchEvent(&event, status);
    }

    if (!mIMEKeyEvents.IsEmpty()) {
      bool ignoreNextKeyPress = false;
      for (uint32_t i = 0; i < mIMEKeyEvents.Length(); i++) {
        const auto event = mIMEKeyEvents[i]->AsKeyboardEvent();
        // widget for duplicated events is initially nullptr.
        event->mWidget = widget;

        status = nsEventStatus_eIgnore;
        if (event->mMessage != eKeyPress) {
          mDispatcher->DispatchKeyboardEvent(event->mMessage, *event, status);
          // Skip default processing. It means that next key press shouldn't
          // be dispatched.
          ignoreNextKeyPress = event->mMessage == eKeyDown &&
                               status == nsEventStatus_eConsumeNoDefault;
        } else {
          if (ignoreNextKeyPress) {
            // Don't dispatch key press since previous key down is consumed.
            ignoreNextKeyPress = false;
            continue;
          }
          mDispatcher->MaybeDispatchKeypressEvents(*event, status);
          if (status == nsEventStatus_eConsumeNoDefault) {
            textChanged = true;
          }
        }
        if (!mDispatcher || widget->Destroyed()) {
          // Don't wait for any text change event.
          textChanged = false;
          break;
        }
      }
      mIMEKeyEvents.Clear();
      return textChanged;
    }

    if (aStart != aEnd) {
      if (composing) {
        // Actually Gecko doesn't start composition, so it is unnecessary to
        // delete content before setting composition string.
        needDispatchCompositionStart = true;
      } else {
        // Perform a deletion first.
        performDeletion = true;
      }
    }
  } else if (composition->String().Equals(string)) {
    // If the new text is the same as the existing composition text,
    // the NS_COMPOSITION_CHANGE event does not generate a text
    // change notification. However, the Java side still expects
    // one, so we manually generate a notification.
    //
    // Also, since this is IME change, we have to set mCausedOnlyByComposition.
    IMENotification::TextChangeData dummyChange(aStart, aEnd, aEnd, true,
                                                false);
    PostFlushIMEChanges();
    mIMESelectionChanged = true;
    AddIMETextChange(dummyChange);
    textChanged = true;
  }

  if (StaticPrefs::
          intl_ime_hack_on_any_apps_fire_key_events_for_composition() ||
      mInputContext.mMayBeIMEUnaware) {
    SendIMEDummyKeyEvent(widget, eKeyDown);
    if (!mDispatcher || widget->Destroyed()) {
      return false;
    }
  }

  if (needDispatchCompositionStart) {
    // StartComposition sets composition string from selected string.
    nsEventStatus status = nsEventStatus_eIgnore;
    mDispatcher->StartComposition(status);
    if (!mDispatcher || widget->Destroyed()) {
      return false;
    }
  } else if (performDeletion) {
    WidgetContentCommandEvent event(true, eContentCommandDelete, widget);
    widget->DispatchEvent(&event, status);
    if (!mDispatcher || widget->Destroyed()) {
      return false;
    }
    textChanged = true;
  }

  if (composing) {
    mDispatcher->SetPendingComposition(string, mIMERanges);
    mDispatcher->FlushPendingComposition(status);
    mIMEActiveCompositionCount++;
    // Ensure IME ranges are empty.
    mIMERanges->Clear();
  } else if (!string.IsEmpty() || mDispatcher->IsComposing()) {
    mDispatcher->CommitComposition(status, &string);
    mIMEActiveCompositionCount++;
    textChanged = true;
  }
  if (!mDispatcher || widget->Destroyed()) {
    return false;
  }

  if (StaticPrefs::
          intl_ime_hack_on_any_apps_fire_key_events_for_composition() ||
      mInputContext.mMayBeIMEUnaware) {
    SendIMEDummyKeyEvent(widget, eKeyUp);
    // Widget may be destroyed after dispatching the above event.
  }
  return textChanged;
}

void GeckoEditableSupport::OnImeAddCompositionRange(
    int32_t aStart, int32_t aEnd, int32_t aRangeType, int32_t aRangeStyle,
    int32_t aRangeLineStyle, bool aRangeBoldLine, int32_t aRangeForeColor,
    int32_t aRangeBackColor, int32_t aRangeLineColor) {
  AutoGeckoEditableBlocker blocker(this);

  if (mIMEMaskEventsCount > 0) {
    // Not focused.
    return;
  }

  TextRange range;
  range.mStartOffset = aStart;
  range.mEndOffset = aEnd;
  range.mRangeType = ToTextRangeType(aRangeType);
  range.mRangeStyle.mDefinedStyles = aRangeStyle;
  range.mRangeStyle.mLineStyle = TextRangeStyle::ToLineStyle(aRangeLineStyle);
  range.mRangeStyle.mIsBoldLine = aRangeBoldLine;
  range.mRangeStyle.mForegroundColor =
      ConvertAndroidColor(uint32_t(aRangeForeColor));
  range.mRangeStyle.mBackgroundColor =
      ConvertAndroidColor(uint32_t(aRangeBackColor));
  range.mRangeStyle.mUnderlineColor =
      ConvertAndroidColor(uint32_t(aRangeLineColor));
  mIMERanges->AppendElement(range);
}

void GeckoEditableSupport::OnImeUpdateComposition(int32_t aStart, int32_t aEnd,
                                                  int32_t aFlags) {
  AutoGeckoEditableBlocker blocker(this);

  if (DoUpdateComposition(aStart, aEnd, aFlags)) {
    mIMEDelaySynchronizeReply = true;
  }
}

bool GeckoEditableSupport::DoUpdateComposition(int32_t aStart, int32_t aEnd,
                                               int32_t aFlags) {
  if (mIMEMaskEventsCount > 0) {
    // Not focused.
    return false;
  }

  nsCOMPtr<nsIWidget> widget = GetWidget();
  nsEventStatus status = nsEventStatus_eIgnore;
  NS_ENSURE_TRUE(mDispatcher && widget, false);

  const bool keepCurrent =
      !!(aFlags & java::GeckoEditableChild::FLAG_KEEP_CURRENT_COMPOSITION);

  // A composition with no ranges means we want to set the selection.
  if (mIMERanges->IsEmpty()) {
    if (keepCurrent && mDispatcher->IsComposing()) {
      // Don't set selection if we want to keep current composition.
      return false;
    }

    MOZ_ASSERT(aStart >= 0 && aEnd >= 0);
    const bool compositionChanged = RemoveComposition();

    WidgetSelectionEvent selEvent(true, eSetSelection, widget);
    selEvent.mOffset = std::min(aStart, aEnd);
    selEvent.mLength = std::max(aStart, aEnd) - selEvent.mOffset;
    selEvent.mReversed = aStart > aEnd;
    selEvent.mExpandToClusterBoundary = false;
    widget->DispatchEvent(&selEvent, status);
    return compositionChanged;
  }

  /**
   * Update the composition from aStart to aEnd using information from added
   * ranges. This is only used for visual indication and does not affect the
   * text content.  Only the offsets are specified and not the text content
   * to eliminate the possibility of this event altering the text content
   * unintentionally.
   */
  nsString string;
  RefPtr<TextComposition> composition(GetComposition());
  MOZ_ASSERT(!composition || !composition->IsEditorHandlingEvent());

  if (!composition || !mDispatcher->IsComposing() ||
      uint32_t(aStart) != composition->NativeOffsetOfStartComposition() ||
      uint32_t(aEnd) != composition->NativeOffsetOfStartComposition() +
                            composition->String().Length()) {
    if (keepCurrent) {
      // Don't start a new composition if we want to keep the current one.
      mIMERanges->Clear();
      return false;
    }

    // Only start new composition if we don't have an existing one,
    // or if the existing composition doesn't match the new one.
    RemoveComposition();

    {
      WidgetSelectionEvent event(true, eSetSelection, widget);
      event.mOffset = uint32_t(aStart);
      event.mLength = uint32_t(aEnd - aStart);
      event.mExpandToClusterBoundary = false;
      event.mReason = nsISelectionListener::IME_REASON;
      widget->DispatchEvent(&event, status);
    }

    {
      WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
                                                     widget);
      widget->DispatchEvent(&querySelectedTextEvent, status);
      MOZ_ASSERT(querySelectedTextEvent.Succeeded());
      if (querySelectedTextEvent.FoundSelection()) {
        string = querySelectedTextEvent.mReply->DataRef();
      }
    }
  } else {
    // If the new composition matches the existing composition,
    // reuse the old composition.
    string = composition->String();
  }

  ALOGIME("IME: IME_SET_TEXT: text=\"%s\", length=%zu, range=%zu",
          NS_ConvertUTF16toUTF8(string).get(), string.Length(),
          mIMERanges->Length());

  if (NS_WARN_IF(NS_FAILED(BeginInputTransaction(mDispatcher)))) {
    mIMERanges->Clear();
    return false;
  }
  mDispatcher->SetPendingComposition(string, mIMERanges);
  mDispatcher->FlushPendingComposition(status);
  mIMEActiveCompositionCount++;
  mIMERanges->Clear();
  return true;
}

void GeckoEditableSupport::OnImeRequestCursorUpdates(int aRequestMode) {
  AutoGeckoEditableBlocker blocker(this);

  if (aRequestMode == EditableClient::ONE_SHOT) {
    UpdateCompositionRects();
    return;
  }

  mIMEMonitorCursor = (aRequestMode == EditableClient::START_MONITOR);
}

class MOZ_STACK_CLASS AutoSelectionRestore final {
 public:
  explicit AutoSelectionRestore(nsIWidget* widget,
                                TextEventDispatcher* dispatcher)
      : mWidget(widget), mDispatcher(dispatcher) {
    MOZ_ASSERT(widget);
    if (!dispatcher || !dispatcher->IsComposing()) {
      mOffset = UINT32_MAX;
      mLength = UINT32_MAX;
      return;
    }
    WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
                                                   widget);
    nsEventStatus status = nsEventStatus_eIgnore;
    widget->DispatchEvent(&querySelectedTextEvent, status);
    if (querySelectedTextEvent.DidNotFindSelection()) {
      mOffset = UINT32_MAX;
      mLength = UINT32_MAX;
      return;
    }

    mOffset = querySelectedTextEvent.mReply->StartOffset();
    mLength = querySelectedTextEvent.mReply->DataLength();
  }

  ~AutoSelectionRestore() {
    if (mWidget->Destroyed() || mOffset == UINT32_MAX) {
      return;
    }

    WidgetSelectionEvent selection(true, eSetSelection, mWidget);
    selection.mOffset = mOffset;
    selection.mLength = mLength;
    selection.mExpandToClusterBoundary = false;
    selection.mReason = nsISelectionListener::IME_REASON;
    nsEventStatus status = nsEventStatus_eIgnore;
    mWidget->DispatchEvent(&selection, status);
  }

 private:
  nsCOMPtr<nsIWidget> mWidget;
  RefPtr<TextEventDispatcher> mDispatcher;
  uint32_t mOffset;
  uint32_t mLength;
};

void GeckoEditableSupport::OnImeRequestCommit() {
  AutoGeckoEditableBlocker blocker(this);

  if (mIMEMaskEventsCount > 0) {
    // Not focused.
    return;
  }

  nsCOMPtr<nsIWidget> widget = GetWidget();
  if (NS_WARN_IF(!widget)) {
    return;
  }

  AutoSelectionRestore restore(widget, mDispatcher);

  RemoveComposition(COMMIT_IME_COMPOSITION);
}

void GeckoEditableSupport::AsyncNotifyIME(int32_t aNotification) {
  RefPtr<GeckoEditableSupport> self(this);

  nsAppShell::PostEvent([this, self, aNotification] {
    if (!mIMEMaskEventsCount) {
      mEditable->NotifyIME(aNotification);
    }
  });
}

nsresult GeckoEditableSupport::NotifyIME(
    TextEventDispatcher* aTextEventDispatcher,
    const IMENotification& aNotification) {
  MOZ_ASSERT(mEditable);

  switch (aNotification.mMessage) {
    case REQUEST_TO_COMMIT_COMPOSITION: {
      ALOGIME("IME: REQUEST_TO_COMMIT_COMPOSITION");

      RemoveComposition(COMMIT_IME_COMPOSITION);
      AsyncNotifyIME(EditableListener::NOTIFY_IME_TO_COMMIT_COMPOSITION);
      break;
    }

    case REQUEST_TO_CANCEL_COMPOSITION: {
      ALOGIME("IME: REQUEST_TO_CANCEL_COMPOSITION");

      RemoveComposition(CANCEL_IME_COMPOSITION);
      AsyncNotifyIME(EditableListener::NOTIFY_IME_TO_CANCEL_COMPOSITION);
      break;
    }

    case NOTIFY_IME_OF_FOCUS: {
      ALOGIME("IME: NOTIFY_IME_OF_FOCUS");

      mIMEFocusCount++;

      RefPtr<GeckoEditableSupport> self(this);
      RefPtr<TextEventDispatcher> dispatcher = aTextEventDispatcher;

      // Post an event because we have to flush the text before sending a
      // focus event, and we may not be able to flush text during the
      // NotifyIME call.
      nsAppShell::PostEvent([this, self, dispatcher] {
        nsCOMPtr<nsIWidget> widget = dispatcher->GetWidget();

        --mIMEMaskEventsCount;
        if (!mIMEFocusCount || !widget || widget->Destroyed()) {
          return;
        }

        mEditable->NotifyIME(EditableListener::NOTIFY_IME_OF_TOKEN);

        if (mIsRemote) {
          if (!mEditableAttached) {
            // Re-attach on focus; see OnRemovedFrom().
            jni::NativeWeakPtrHolder<GeckoEditableSupport>::AttachExisting(
                mEditable, do_AddRef(this));
            mEditableAttached = true;
          }
          // Because GeckoEditableSupport in content process doesn't
          // manage the active input context, we need to retrieve the
          // input context from the widget, for use by
          // OnImeReplaceText.
          mInputContext = widget->GetInputContext();
        }
        mDispatcher = dispatcher;
        mIMEKeyEvents.Clear();

        mCachedSelection.Reset();

        mIMEDelaySynchronizeReply = false;
        mIMEActiveCompositionCount = 0;
        FlushIMEText();

        // IME will call requestCursorUpdates after getting context.
        // So reset cursor update mode before getting context.
        mIMEMonitorCursor = false;

        mEditable->NotifyIME(EditableListener::NOTIFY_IME_OF_FOCUS);
      });
      break;
    }

    case NOTIFY_IME_OF_BLUR: {
      ALOGIME("IME: NOTIFY_IME_OF_BLUR");

      mIMEFocusCount--;
      MOZ_ASSERT(mIMEFocusCount >= 0);

      RefPtr<GeckoEditableSupport> self(this);
      nsAppShell::PostEvent([this, self] {
        if (!mIMEFocusCount) {
          mIMEDelaySynchronizeReply = false;
          mIMEActiveSynchronizeCount = 0;
          mIMEActiveCompositionCount = 0;
          mInputContext.ShutDown();
          mEditable->NotifyIME(EditableListener::NOTIFY_IME_OF_BLUR);
          OnRemovedFrom(mDispatcher);
        }
      });

      // Mask events because we lost focus. Unmask on the next focus.
      mIMEMaskEventsCount++;
      break;
    }

    case NOTIFY_IME_OF_SELECTION_CHANGE: {
      ALOGIME("IME: NOTIFY_IME_OF_SELECTION_CHANGE: SelectionChangeData=%s",
              ToString(aNotification.mSelectionChangeData).c_str());

      if (aNotification.mSelectionChangeData.HasRange()) {
        mCachedSelection.mStartOffset = static_cast<int32_t>(
            aNotification.mSelectionChangeData.AnchorOffset());
        mCachedSelection.mEndOffset = static_cast<int32_t>(
            aNotification.mSelectionChangeData.FocusOffset());
      } else {
        mCachedSelection.Reset();
      }

      PostFlushIMEChanges();
      mIMESelectionChanged = true;
      break;
    }

    case NOTIFY_IME_OF_TEXT_CHANGE: {
      ALOGIME("IME: NOTIFY_IME_OF_TEXT_CHANGE: TextChangeData=%s",
              ToString(aNotification.mTextChangeData).c_str());

      /* Make sure Java's selection is up-to-date */
      PostFlushIMEChanges();
      mIMESelectionChanged = true;
      AddIMETextChange(aNotification.mTextChangeData);
      break;
    }

    case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED: {
      ALOGIME("IME: NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED");

      // NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED isn't sent per IME call.
      // Receiving this event means that Gecko has already handled all IME
      // composing events in queue.
      //
      if (mIsRemote) {
        OnNotifyIMEOfCompositionEventHandled();
      } else {
        // Also, when receiving this event, mIMEDelaySynchronizeReply won't
        // update yet on non-e10s case since IME event is posted before updating
        // it. So we have to delay handling of this event.
        RefPtr<GeckoEditableSupport> self(this);
        nsAppShell::PostEvent(
            [this, self] { OnNotifyIMEOfCompositionEventHandled(); });
      }
      break;
    }

    default:
      break;
  }
  return NS_OK;
}

void GeckoEditableSupport::OnNotifyIMEOfCompositionEventHandled() {
  // NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED may be merged with multiple events,
  // so reset count.
  mIMEActiveCompositionCount = 0;
  if (mIMEDelaySynchronizeReply) {
    FlushIMEChanges();
  }

  // Hardware keyboard support requires each string rect.
  if (mIMEMonitorCursor) {
    UpdateCompositionRects();
  }
}

void GeckoEditableSupport::OnRemovedFrom(
    TextEventDispatcher* aTextEventDispatcher) {
  mDispatcher = nullptr;

  if (mIsRemote && mEditable->HasEditableParent()) {
    // When we're remote, detach every time.
    OnWeakNonIntrusiveDetach(NS_NewRunnableFunction(
        "GeckoEditableSupport::OnRemovedFrom",
        [editable = java::GeckoEditableChild::GlobalRef(mEditable)] {
          DisposeNative(editable);
        }));
  }
}

void GeckoEditableSupport::WillDispatchKeyboardEvent(
    TextEventDispatcher* aTextEventDispatcher,
    WidgetKeyboardEvent& aKeyboardEvent, uint32_t aIndexOfKeypress,
    void* aData) {}

NS_IMETHODIMP_(IMENotificationRequests)
GeckoEditableSupport::GetIMENotificationRequests() {
  return IMENotificationRequests(IMENotificationRequests::NOTIFY_TEXT_CHANGE);
}

static bool ShouldKeyboardDismiss(const nsAString& aInputType,
                                  const nsAString& aInputMode) {
  // Some input type uses the prompt to input value. So it is unnecessary to
  // show software keyboard.
  return aInputMode.EqualsLiteral("none") || aInputType.EqualsLiteral("date") ||
         aInputType.EqualsLiteral("time") ||
         aInputType.EqualsLiteral("month") ||
         aInputType.EqualsLiteral("week") ||
         aInputType.EqualsLiteral("datetime-local");
}

void GeckoEditableSupport::SetInputContext(const InputContext& aContext,
                                           const InputContextAction& aAction) {
  // SetInputContext is called from chrome process only
  MOZ_ASSERT(XRE_IsParentProcess());
  MOZ_ASSERT(mEditable);

  ALOGIME(
      "IME: SetInputContext: aContext=%s, "
      "aAction={mCause=%s, mFocusChange=%s}",
      ToString(aContext).c_str(), ToString(aAction.mCause).c_str(),
      ToString(aAction.mFocusChange).c_str());

  mInputContext = aContext;

  if (mInputContext.mIMEState.mEnabled != IMEEnabled::Disabled &&
      !ShouldKeyboardDismiss(mInputContext.mHTMLInputType,
                             mInputContext.mHTMLInputMode) &&
      aAction.UserMightRequestOpenVKB()) {
    // Don't reset keyboard when we should simply open the vkb
    mEditable->NotifyIME(EditableListener::NOTIFY_IME_OPEN_VKB);
    return;
  }

  // Post an event to keep calls in order relative to NotifyIME.
  nsAppShell::PostEvent([this, self = RefPtr<GeckoEditableSupport>(this),
                         context = mInputContext, action = aAction] {
    nsCOMPtr<nsIWidget> widget = GetWidget();

    if (!widget || widget->Destroyed()) {
      return;
    }
    NotifyIMEContext(context, action);
  });
}

void GeckoEditableSupport::NotifyIMEContext(const InputContext& aContext,
                                            const InputContextAction& aAction) {
  const bool inPrivateBrowsing = aContext.mInPrivateBrowsing;
  // isUserAction is used whether opening virtual keyboard. But long press
  // shouldn't open it.
  const bool isUserAction =
      aAction.mCause != InputContextAction::CAUSE_LONGPRESS &&
      !(aAction.mCause == InputContextAction::CAUSE_UNKNOWN_CHROME &&
        aContext.mIMEState.mEnabled == IMEEnabled::Enabled) &&
      (aAction.IsHandlingUserInput() || aContext.mHasHandledUserInput);
  const int32_t flags =
      (inPrivateBrowsing ? EditableListener::IME_FLAG_PRIVATE_BROWSING : 0) |
      (isUserAction ? EditableListener::IME_FLAG_USER_ACTION : 0) |
      (aAction.mFocusChange == InputContextAction::FOCUS_NOT_CHANGED
           ? EditableListener::IME_FOCUS_NOT_CHANGED
           : 0);

  mEditable->NotifyIMEContext(static_cast<int32_t>(aContext.mIMEState.mEnabled),
                              aContext.mHTMLInputType, aContext.mHTMLInputMode,
                              aContext.mActionHint, aContext.mAutocapitalize,
                              flags);
}

InputContext GeckoEditableSupport::GetInputContext() {
  // GetInputContext is called from chrome process only
  MOZ_ASSERT(XRE_IsParentProcess());
  InputContext context = mInputContext;
  context.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
  return context;
}

void GeckoEditableSupport::TransferParent(jni::Object::Param aEditableParent) {
  AutoGeckoEditableBlocker blocker(this);

  mEditable->SetParent(aEditableParent);

  // If we are already focused, make sure the new parent has our token
  // and focus information, so it can accept additional calls from us.
  if (mIMEFocusCount > 0) {
    mEditable->NotifyIME(EditableListener::NOTIFY_IME_OF_TOKEN);
    if (mIsRemote) {
      // GeckoEditableSupport::SetInputContext is called on chrome process
      // only, so mInputContext may be still invalid since it is set after
      // we have gotton focus.
      RefPtr<GeckoEditableSupport> self(this);
      nsAppShell::PostEvent([self = std::move(self)] {
        NS_WARNING_ASSERTION(
            self->mDispatcher,
            "Text dispatcher is still null. Why don't we get focus yet?");
        self->NotifyIMEContext(self->mInputContext, InputContextAction());
      });
    } else {
      NotifyIMEContext(mInputContext, InputContextAction());
    }
    mEditable->NotifyIME(EditableListener::NOTIFY_IME_OF_FOCUS);
    // We have focus, so don't destroy editable child.
    return;
  }

  if (mIsRemote && !mDispatcher) {
    // Detach now if we were only attached temporarily.
    OnRemovedFrom(/* dispatcher */ nullptr);
  }
}

void GeckoEditableSupport::SetOnBrowserChild(dom::BrowserChild* aBrowserChild) {
  MOZ_ASSERT(!XRE_IsParentProcess());
  NS_ENSURE_TRUE_VOID(aBrowserChild);

  const dom::ContentChild* const contentChild =
      dom::ContentChild::GetSingleton();
  RefPtr<widget::PuppetWidget> widget(aBrowserChild->WebWidget());
  NS_ENSURE_TRUE_VOID(contentChild && widget);

  // Get the content/tab ID in order to get the correct
  // IGeckoEditableParent object, which GeckoEditableChild uses to
  // communicate with the parent process.
  const uint64_t contentId = contentChild->GetID();
  const uint64_t tabId = aBrowserChild->GetTabId();
  NS_ENSURE_TRUE_VOID(contentId && tabId);

  RefPtr<widget::TextEventDispatcherListener> listener =
      widget->GetNativeTextEventDispatcherListener();

  if (!listener ||
      listener.get() ==
          static_cast<widget::TextEventDispatcherListener*>(widget)) {
    // We need to set a new listener.
    const auto editableChild = java::GeckoEditableChild::New(
        /* parent */ nullptr, /* default */ false);

    // Temporarily attach so we can receive the initial editable parent.
    auto editableSupport =
        jni::NativeWeakPtrHolder<GeckoEditableSupport>::Attach(editableChild,
                                                               editableChild);
    auto accEditableSupport(editableSupport.Access());
    MOZ_RELEASE_ASSERT(accEditableSupport);

    // Tell PuppetWidget to use our listener for IME operations.
    widget->SetNativeTextEventDispatcherListener(
        accEditableSupport.AsRefPtr().get());

    accEditableSupport->mEditableAttached = true;

    // Connect the new child to a parent that corresponds to the BrowserChild.
    java::GeckoServiceChildProcess::GetEditableParent(editableChild, contentId,
                                                      tabId);
    return;
  }

  // We need to update the existing listener to use the new parent.

  // We expect the existing TextEventDispatcherListener to be a
  // GeckoEditableSupport object, so we perform a sanity check to make
  // sure, by comparing their respective vtable pointers.
  const RefPtr<widget::GeckoEditableSupport> dummy =
      new widget::GeckoEditableSupport(/* child */ nullptr);
  NS_ENSURE_TRUE_VOID(*reinterpret_cast<const uintptr_t*>(listener.get()) ==
                      *reinterpret_cast<const uintptr_t*>(dummy.get()));

  const auto support =
      static_cast<widget::GeckoEditableSupport*>(listener.get());
  if (!support->mEditableAttached) {
    // Temporarily attach so we can receive the initial editable parent.
    jni::NativeWeakPtrHolder<GeckoEditableSupport>::AttachExisting(
        support->GetJavaEditable(), do_AddRef(support));
    support->mEditableAttached = true;
  }

  // Transfer to a new parent that corresponds to the BrowserChild.
  java::GeckoServiceChildProcess::GetEditableParent(support->GetJavaEditable(),
                                                    contentId, tabId);
}

nsIWidget* GeckoEditableSupport::GetWidget() const {
  MOZ_ASSERT(NS_IsMainThread());
  return mDispatcher ? mDispatcher->GetWidget() : GetNsWindow();
}

nsWindow* GeckoEditableSupport::GetNsWindow() const {
  MOZ_ASSERT(NS_IsMainThread());

  auto acc(mWindow.Access());
  if (!acc) {
    return nullptr;
  }

  return acc->GetNsWindow();
}

void GeckoEditableSupport::OnImeInsertImage(jni::ByteArray::Param aData,
                                            jni::String::Param aMimeType) {
  AutoGeckoEditableBlocker blocker(this);

  nsCString mimeType(aMimeType->ToCString());
  nsCOMPtr<nsIInputStream> byteStream;

  nsresult rv = NS_NewByteInputStream(
      getter_AddRefs(byteStream),
      mozilla::Span(
          reinterpret_cast<const char*>(aData->GetElements().Elements()),
          aData->Length()),
      NS_ASSIGNMENT_COPY);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return;
  }

  nsCOMPtr<nsITransferable> trans =
      do_CreateInstance("@mozilla.org/widget/transferable;1");
  if (NS_WARN_IF(!trans)) {
    return;
  }
  trans->Init(nullptr);
  rv = trans->SetTransferData(mimeType.get(), byteStream);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return;
  }

  nsCOMPtr<nsIWidget> widget = GetWidget();
  if (NS_WARN_IF(!widget) || NS_WARN_IF(widget->Destroyed())) {
    return;
  }

  WidgetContentCommandEvent command(true, eContentCommandPasteTransferable,
                                    widget);
  command.mTransferable = trans.forget();
  nsEventStatus status;
  widget->DispatchEvent(&command, status);
}

}  // namespace widget
}  // namespace mozilla