Add m-esr52 at 52.6.0

1 files changed, 1561 insertions, 0 deletions

diff --git a/dom/inputmethod/forms.js b/dom/inputmethod/forms.js
new file mode 100644
index 000000000..1884f2b4d
--- /dev/null
+++ b/dom/inputmethod/forms.js
@@ -0,0 +1,1561 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- /
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent 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/. */
+
+"use strict";
+
+dump("###################################### forms.js loaded\n");
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cu = Components.utils;
+var Cr = Components.results;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+XPCOMUtils.defineLazyServiceGetter(Services, "fm",
+                                   "@mozilla.org/focus-manager;1",
+                                   "nsIFocusManager");
+
+/*
+ * A WeakMap to map window to objects keeping it's TextInputProcessor instance.
+ */
+var WindowMap = {
+  // WeakMap of <window, object> pairs.
+  _map: null,
+
+  /*
+   * Set the object associated to the window and return it.
+   */
+  _getObjForWin: function(win) {
+    if (!this._map) {
+      this._map = new WeakMap();
+    }
+    if (this._map.has(win)) {
+      return this._map.get(win);
+    } else {
+      let obj = {
+        tip: null
+      };
+      this._map.set(win, obj);
+
+      return obj;
+    }
+  },
+
+  getTextInputProcessor: function(win) {
+    if (!win) {
+      return;
+    }
+    let obj = this._getObjForWin(win);
+    let tip = obj.tip
+
+    if (!tip) {
+      tip = obj.tip = Cc["@mozilla.org/text-input-processor;1"]
+        .createInstance(Ci.nsITextInputProcessor);
+    }
+
+    if (!tip.beginInputTransaction(win, textInputProcessorCallback)) {
+      tip = obj.tip = null;
+    }
+    return tip;
+  }
+};
+
+const RESIZE_SCROLL_DELAY = 20;
+// In content editable node, when there are hidden elements such as <br>, it
+// may need more than one (usually less than 3 times) move/extend operations
+// to change the selection range. If we cannot change the selection range
+// with more than 20 opertations, we are likely being blocked and cannot change
+// the selection range any more.
+const MAX_BLOCKED_COUNT = 20;
+
+var HTMLDocument = Ci.nsIDOMHTMLDocument;
+var HTMLHtmlElement = Ci.nsIDOMHTMLHtmlElement;
+var HTMLBodyElement = Ci.nsIDOMHTMLBodyElement;
+var HTMLIFrameElement = Ci.nsIDOMHTMLIFrameElement;
+var HTMLInputElement = Ci.nsIDOMHTMLInputElement;
+var HTMLTextAreaElement = Ci.nsIDOMHTMLTextAreaElement;
+var HTMLSelectElement = Ci.nsIDOMHTMLSelectElement;
+var HTMLOptGroupElement = Ci.nsIDOMHTMLOptGroupElement;
+var HTMLOptionElement = Ci.nsIDOMHTMLOptionElement;
+
+function guessKeyNameFromKeyCode(KeyboardEvent, aKeyCode) {
+  switch (aKeyCode) {
+    case KeyboardEvent.DOM_VK_CANCEL:
+      return "Cancel";
+    case KeyboardEvent.DOM_VK_HELP:
+      return "Help";
+    case KeyboardEvent.DOM_VK_BACK_SPACE:
+      return "Backspace";
+    case KeyboardEvent.DOM_VK_TAB:
+      return "Tab";
+    case KeyboardEvent.DOM_VK_CLEAR:
+      return "Clear";
+    case KeyboardEvent.DOM_VK_RETURN:
+      return "Enter";
+    case KeyboardEvent.DOM_VK_SHIFT:
+      return "Shift";
+    case KeyboardEvent.DOM_VK_CONTROL:
+      return "Control";
+    case KeyboardEvent.DOM_VK_ALT:
+      return "Alt";
+    case KeyboardEvent.DOM_VK_PAUSE:
+      return "Pause";
+    case KeyboardEvent.DOM_VK_EISU:
+      return "Eisu";
+    case KeyboardEvent.DOM_VK_ESCAPE:
+      return "Escape";
+    case KeyboardEvent.DOM_VK_CONVERT:
+      return "Convert";
+    case KeyboardEvent.DOM_VK_NONCONVERT:
+      return "NonConvert";
+    case KeyboardEvent.DOM_VK_ACCEPT:
+      return "Accept";
+    case KeyboardEvent.DOM_VK_MODECHANGE:
+      return "ModeChange";
+    case KeyboardEvent.DOM_VK_PAGE_UP:
+      return "PageUp";
+    case KeyboardEvent.DOM_VK_PAGE_DOWN:
+      return "PageDown";
+    case KeyboardEvent.DOM_VK_END:
+      return "End";
+    case KeyboardEvent.DOM_VK_HOME:
+      return "Home";
+    case KeyboardEvent.DOM_VK_LEFT:
+      return "ArrowLeft";
+    case KeyboardEvent.DOM_VK_UP:
+      return "ArrowUp";
+    case KeyboardEvent.DOM_VK_RIGHT:
+      return "ArrowRight";
+    case KeyboardEvent.DOM_VK_DOWN:
+      return "ArrowDown";
+    case KeyboardEvent.DOM_VK_SELECT:
+      return "Select";
+    case KeyboardEvent.DOM_VK_PRINT:
+      return "Print";
+    case KeyboardEvent.DOM_VK_EXECUTE:
+      return "Execute";
+    case KeyboardEvent.DOM_VK_PRINTSCREEN:
+      return "PrintScreen";
+    case KeyboardEvent.DOM_VK_INSERT:
+      return "Insert";
+    case KeyboardEvent.DOM_VK_DELETE:
+      return "Delete";
+    case KeyboardEvent.DOM_VK_WIN:
+      return "OS";
+    case KeyboardEvent.DOM_VK_CONTEXT_MENU:
+      return "ContextMenu";
+    case KeyboardEvent.DOM_VK_SLEEP:
+      return "Standby";
+    case KeyboardEvent.DOM_VK_F1:
+      return "F1";
+    case KeyboardEvent.DOM_VK_F2:
+      return "F2";
+    case KeyboardEvent.DOM_VK_F3:
+      return "F3";
+    case KeyboardEvent.DOM_VK_F4:
+      return "F4";
+    case KeyboardEvent.DOM_VK_F5:
+      return "F5";
+    case KeyboardEvent.DOM_VK_F6:
+      return "F6";
+    case KeyboardEvent.DOM_VK_F7:
+      return "F7";
+    case KeyboardEvent.DOM_VK_F8:
+      return "F8";
+    case KeyboardEvent.DOM_VK_F9:
+      return "F9";
+    case KeyboardEvent.DOM_VK_F10:
+      return "F10";
+    case KeyboardEvent.DOM_VK_F11:
+      return "F11";
+    case KeyboardEvent.DOM_VK_F12:
+      return "F12";
+    case KeyboardEvent.DOM_VK_F13:
+      return "F13";
+    case KeyboardEvent.DOM_VK_F14:
+      return "F14";
+    case KeyboardEvent.DOM_VK_F15:
+      return "F15";
+    case KeyboardEvent.DOM_VK_F16:
+      return "F16";
+    case KeyboardEvent.DOM_VK_F17:
+      return "F17";
+    case KeyboardEvent.DOM_VK_F18:
+      return "F18";
+    case KeyboardEvent.DOM_VK_F19:
+      return "F19";
+    case KeyboardEvent.DOM_VK_F20:
+      return "F20";
+    case KeyboardEvent.DOM_VK_F21:
+      return "F21";
+    case KeyboardEvent.DOM_VK_F22:
+      return "F22";
+    case KeyboardEvent.DOM_VK_F23:
+      return "F23";
+    case KeyboardEvent.DOM_VK_F24:
+      return "F24";
+    case KeyboardEvent.DOM_VK_NUM_LOCK:
+      return "NumLock";
+    case KeyboardEvent.DOM_VK_SCROLL_LOCK:
+      return "ScrollLock";
+    case KeyboardEvent.DOM_VK_VOLUME_MUTE:
+      return "AudioVolumeMute";
+    case KeyboardEvent.DOM_VK_VOLUME_DOWN:
+      return "AudioVolumeDown";
+    case KeyboardEvent.DOM_VK_VOLUME_UP:
+      return "AudioVolumeUp";
+    case KeyboardEvent.DOM_VK_META:
+      return "Meta";
+    case KeyboardEvent.DOM_VK_ALTGR:
+      return "AltGraph";
+    case KeyboardEvent.DOM_VK_ATTN:
+      return "Attn";
+    case KeyboardEvent.DOM_VK_CRSEL:
+      return "CrSel";
+    case KeyboardEvent.DOM_VK_EXSEL:
+      return "ExSel";
+    case KeyboardEvent.DOM_VK_EREOF:
+      return "EraseEof";
+    case KeyboardEvent.DOM_VK_PLAY:
+      return "Play";
+    default:
+      return "Unidentified";
+  }
+}
+
+var FormVisibility = {
+  /**
+   * Searches upwards in the DOM for an element that has been scrolled.
+   *
+   * @param {HTMLElement} node element to start search at.
+   * @return {Window|HTMLElement|Null} null when none are found window/element otherwise.
+   */
+  findScrolled: function fv_findScrolled(node) {
+    let win = node.ownerDocument.defaultView;
+
+    while (!(node instanceof HTMLBodyElement)) {
+
+      // We can skip elements that have not been scrolled.
+      // We only care about top now remember to add the scrollLeft
+      // check if we decide to care about the X axis.
+      if (node.scrollTop !== 0) {
+        // the element has been scrolled so we may need to adjust
+        // where we think the root element is located.
+        //
+        // Otherwise it may seem visible but be scrolled out of the viewport
+        // inside this scrollable node.
+        return node;
+      } else {
+        // this node does not effect where we think
+        // the node is even if it is scrollable it has not hidden
+        // the element we are looking for.
+        node = node.parentNode;
+        continue;
+      }
+    }
+
+    // we also care about the window this is the more
+    // common case where the content is larger then
+    // the viewport/screen.
+    if (win.scrollMaxX != win.scrollMinX || win.scrollMaxY != win.scrollMinY) {
+      return win;
+    }
+
+    return null;
+  },
+
+  /**
+   * Checks if "top  and "bottom" points of the position is visible.
+   *
+   * @param {Number} top position.
+   * @param {Number} height of the element.
+   * @param {Number} maxHeight of the window.
+   * @return {Boolean} true when visible.
+   */
+  yAxisVisible: function fv_yAxisVisible(top, height, maxHeight) {
+    return (top > 0 && (top + height) < maxHeight);
+  },
+
+  /**
+   * Searches up through the dom for scrollable elements
+   * which are not currently visible (relative to the viewport).
+   *
+   * @param {HTMLElement} element to start search at.
+   * @param {Object} pos .top, .height and .width of element.
+   */
+  scrollablesVisible: function fv_scrollablesVisible(element, pos) {
+    while ((element = this.findScrolled(element))) {
+      if (element.window && element.self === element)
+        break;
+
+      // remember getBoundingClientRect does not care
+      // about scrolling only where the element starts
+      // in the document.
+      let offset = element.getBoundingClientRect();
+
+      // the top of both the scrollable area and
+      // the form element itself are in the same document.
+      // We  adjust the "top" so if the elements coordinates
+      // are relative to the viewport in the current document.
+      let adjustedTop = pos.top - offset.top;
+
+      let visible = this.yAxisVisible(
+        adjustedTop,
+        pos.height,
+        offset.height
+      );
+
+      if (!visible)
+        return false;
+
+      element = element.parentNode;
+    }
+
+    return true;
+  },
+
+  /**
+   * Verifies the element is visible in the viewport.
+   * Handles scrollable areas, frames and scrollable viewport(s) (windows).
+   *
+   * @param {HTMLElement} element to verify.
+   * @return {Boolean} true when visible.
+   */
+  isVisible: function fv_isVisible(element) {
+    // scrollable frames can be ignored we just care about iframes...
+    let rect = element.getBoundingClientRect();
+    let parent = element.ownerDocument.defaultView;
+
+    // used to calculate the inner position of frames / scrollables.
+    // The intent was to use this information to scroll either up or down.
+    // scrollIntoView(true) will _break_ some web content so we can't do
+    // this today. If we want that functionality we need to manually scroll
+    // the individual elements.
+    let pos = {
+      top: rect.top,
+      height: rect.height,
+      width: rect.width
+    };
+
+    let visible = true;
+
+    do {
+      let frame = parent.frameElement;
+      visible = visible &&
+                this.yAxisVisible(pos.top, pos.height, parent.innerHeight) &&
+                this.scrollablesVisible(element, pos);
+
+      // nothing we can do about this now...
+      // In the future we can use this information to scroll
+      // only the elements we need to at this point as we should
+      // have all the details we need to figure out how to scroll.
+      if (!visible)
+        return false;
+
+      if (frame) {
+        let frameRect = frame.getBoundingClientRect();
+
+        pos.top += frameRect.top + frame.clientTop;
+      }
+    } while (
+      (parent !== parent.parent) &&
+      (parent = parent.parent)
+    );
+
+    return visible;
+  }
+};
+
+// This object implements nsITextInputProcessorCallback
+var textInputProcessorCallback = {
+  onNotify: function(aTextInputProcessor, aNotification) {
+    try {
+      switch (aNotification.type) {
+        case "request-to-commit":
+          // TODO: Send a notification through asyncMessage to the keyboard here.
+          aTextInputProcessor.commitComposition();
+
+          break;
+        case "request-to-cancel":
+          // TODO: Send a notification through asyncMessage to the keyboard here.
+          aTextInputProcessor.cancelComposition();
+
+          break;
+
+        case "notify-detached":
+          // TODO: Send a notification through asyncMessage to the keyboard here.
+          break;
+
+        // TODO: Manage _focusedElement for text input from here instead.
+        //       (except for <select> which will be need to handled elsewhere)
+        case "notify-focus":
+          break;
+
+        case "notify-blur":
+          break;
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+};
+
+var FormAssistant = {
+  init: function fa_init() {
+    addEventListener("focus", this, true, false);
+    addEventListener("blur", this, true, false);
+    addEventListener("resize", this, true, false);
+    // We should not blur the fucus if the submit event is cancelled,
+    // therefore we are binding our event listener in the bubbling phase here.
+    addEventListener("submit", this, false, false);
+    addEventListener("pagehide", this, true, false);
+    addEventListener("beforeunload", this, true, false);
+    addEventListener("input", this, true, false);
+    addEventListener("keydown", this, true, false);
+    addEventListener("keyup", this, true, false);
+    addMessageListener("Forms:Select:Choice", this);
+    addMessageListener("Forms:Input:Value", this);
+    addMessageListener("Forms:Select:Blur", this);
+    addMessageListener("Forms:SetSelectionRange", this);
+    addMessageListener("Forms:ReplaceSurroundingText", this);
+    addMessageListener("Forms:Input:SendKey", this);
+    addMessageListener("Forms:GetContext", this);
+    addMessageListener("Forms:SetComposition", this);
+    addMessageListener("Forms:EndComposition", this);
+  },
+
+  ignoredInputTypes: new Set([
+    'button', 'file', 'checkbox', 'radio', 'reset', 'submit', 'image',
+    'range'
+  ]),
+
+  isHandlingFocus: false,
+  selectionStart: -1,
+  selectionEnd: -1,
+  text: "",
+
+  scrollIntoViewTimeout: null,
+  _focusedElement: null,
+  _focusCounter: 0, // up one for every time we focus a new element
+  _focusDeleteObserver: null,
+  _focusContentObserver: null,
+  _documentEncoder: null,
+  _editor: null,
+  _editing: false,
+  _selectionPrivate: null,
+
+  get focusedElement() {
+    if (this._focusedElement && Cu.isDeadWrapper(this._focusedElement))
+      this._focusedElement = null;
+
+    return this._focusedElement;
+  },
+
+  set focusedElement(val) {
+    this._focusCounter++;
+    this._focusedElement = val;
+  },
+
+  setFocusedElement: function fa_setFocusedElement(element) {
+    let self = this;
+
+    if (element === this.focusedElement)
+      return;
+
+    if (this.focusedElement) {
+      this.focusedElement.removeEventListener('compositionend', this);
+      if (this._focusDeleteObserver) {
+        this._focusDeleteObserver.disconnect();
+        this._focusDeleteObserver = null;
+      }
+      if (this._focusContentObserver) {
+        this._focusContentObserver.disconnect();
+        this._focusContentObserver = null;
+      }
+      if (this._selectionPrivate) {
+        this._selectionPrivate.removeSelectionListener(this);
+        this._selectionPrivate = null;
+      }
+    }
+
+    this._documentEncoder = null;
+    if (this._editor) {
+      // When the nsIFrame of the input element is reconstructed by
+      // CSS restyling, the editor observers are removed. Catch
+      // [nsIEditor.removeEditorObserver] failure exception if that
+      // happens.
+      try {
+        this._editor.removeEditorObserver(this);
+      } catch (e) {}
+      this._editor = null;
+    }
+
+    if (element) {
+      element.addEventListener('compositionend', this);
+      if (isContentEditable(element)) {
+        this._documentEncoder = getDocumentEncoder(element);
+      }
+      this._editor = getPlaintextEditor(element);
+      if (this._editor) {
+        // Add a nsIEditorObserver to monitor the text content of the focused
+        // element.
+        this._editor.addEditorObserver(this);
+
+        let selection = this._editor.selection;
+        if (selection) {
+          this._selectionPrivate = selection.QueryInterface(Ci.nsISelectionPrivate);
+          this._selectionPrivate.addSelectionListener(this);
+        }
+      }
+
+      // If our focusedElement is removed from DOM we want to handle it properly
+      let MutationObserver = element.ownerDocument.defaultView.MutationObserver;
+      this._focusDeleteObserver = new MutationObserver(function(mutations) {
+        var del = [].some.call(mutations, function(m) {
+          return [].some.call(m.removedNodes, function(n) {
+            return n.contains(element);
+          });
+        });
+        if (del && element === self.focusedElement) {
+          self.unhandleFocus();
+        }
+      });
+
+      this._focusDeleteObserver.observe(element.ownerDocument.body, {
+        childList: true,
+        subtree: true
+      });
+
+      // If contenteditable, also add a mutation observer on its content and
+      // call selectionChanged when a change occurs
+      if (isContentEditable(element)) {
+        this._focusContentObserver = new MutationObserver(function() {
+          this.updateSelection();
+        }.bind(this));
+
+        this._focusContentObserver.observe(element, {
+          childList: true,
+          subtree: true
+        });
+      }
+    }
+
+    this.focusedElement = element;
+  },
+
+  notifySelectionChanged: function(aDocument, aSelection, aReason) {
+    this.updateSelection();
+  },
+
+  get documentEncoder() {
+    return this._documentEncoder;
+  },
+
+  // Get the nsIPlaintextEditor object of current input field.
+  get editor() {
+    return this._editor;
+  },
+
+  // Implements nsIEditorObserver get notification when the text content of
+  // current input field has changed.
+  EditAction: function fa_editAction() {
+    if (this._editing || !this.isHandlingFocus) {
+      return;
+    }
+    this.sendInputState(this.focusedElement);
+  },
+
+  handleEvent: function fa_handleEvent(evt) {
+    let target = evt.composedTarget;
+
+    let range = null;
+    switch (evt.type) {
+      case "focus":
+        if (!target) {
+          break;
+        }
+
+        // Focusing on Window, Document or iFrame should focus body
+        if (target instanceof HTMLHtmlElement) {
+          target = target.document.body;
+        } else if (target instanceof HTMLDocument) {
+          target = target.body;
+        } else if (target instanceof HTMLIFrameElement) {
+          target = target.contentDocument ? target.contentDocument.body
+                                          : null;
+        }
+
+        if (!target) {
+          break;
+        }
+
+        if (isContentEditable(target)) {
+          this.handleFocus(this.getTopLevelEditable(target));
+          this.updateSelection();
+          break;
+        }
+
+        if (this.isFocusableElement(target)) {
+          this.handleFocus(target);
+          this.updateSelection();
+        }
+        break;
+
+      case "pagehide":
+      case "beforeunload":
+        // We are only interested to the pagehide and beforeunload events from
+        // the root document.
+        if (target && target != content.document) {
+          break;
+        }
+        // fall through
+      case "submit":
+        if (this.focusedElement && !evt.defaultPrevented) {
+          this.focusedElement.blur();
+        }
+        break;
+
+      case "blur":
+        if (this.focusedElement) {
+          this.unhandleFocus();
+        }
+        break;
+
+      case "resize":
+        if (!this.isHandlingFocus)
+          return;
+
+        if (this.scrollIntoViewTimeout) {
+          content.clearTimeout(this.scrollIntoViewTimeout);
+          this.scrollIntoViewTimeout = null;
+        }
+
+        // We may receive multiple resize events in quick succession, so wait
+        // a bit before scrolling the input element into view.
+        if (this.focusedElement) {
+          this.scrollIntoViewTimeout = content.setTimeout(function () {
+            this.scrollIntoViewTimeout = null;
+            if (this.focusedElement && !FormVisibility.isVisible(this.focusedElement)) {
+              scrollSelectionOrElementIntoView(this.focusedElement);
+            }
+          }.bind(this), RESIZE_SCROLL_DELAY);
+        }
+        break;
+
+      case "keydown":
+        if (!this.focusedElement || this._editing) {
+          break;
+        }
+
+        CompositionManager.endComposition('');
+        break;
+
+      case "keyup":
+        if (!this.focusedElement || this._editing) {
+          break;
+        }
+
+        CompositionManager.endComposition('');
+        break;
+
+      case "compositionend":
+        if (!this.focusedElement) {
+          break;
+        }
+
+        CompositionManager.onCompositionEnd();
+        break;
+    }
+  },
+
+  receiveMessage: function fa_receiveMessage(msg) {
+    let target = this.focusedElement;
+    let json = msg.json;
+
+    // To not break mozKeyboard contextId is optional
+    if ('contextId' in json &&
+        json.contextId !== this._focusCounter &&
+        json.requestId) {
+      // Ignore messages that are meant for a previously focused element
+      sendAsyncMessage("Forms:SequenceError", {
+        requestId: json.requestId,
+        error: "Expected contextId " + this._focusCounter +
+               " but was " + json.contextId
+      });
+      return;
+    }
+
+    if (!target) {
+      return;
+    }
+
+    this._editing = true;
+    switch (msg.name) {
+      case "Forms:Input:Value": {
+        CompositionManager.endComposition('');
+
+        target.value = json.value;
+
+        let event = target.ownerDocument.createEvent('HTMLEvents');
+        event.initEvent('input', true, false);
+        target.dispatchEvent(event);
+        break;
+      }
+
+      case "Forms:Input:SendKey":
+        CompositionManager.endComposition('');
+
+        let win = target.ownerDocument.defaultView;
+        let tip = WindowMap.getTextInputProcessor(win);
+        if (!tip) {
+          if (json.requestId) {
+            sendAsyncMessage("Forms:SendKey:Result:Error", {
+              requestId: json.requestId,
+              error: "Unable to start input transaction."
+            });
+          }
+
+          break;
+        }
+
+        // If we receive a keyboardEventDict from json, that means the user
+        // is calling the method with the new arguments.
+        // Otherwise, we would have to construct our own keyboardEventDict
+        // based on legacy values we have received.
+        let keyboardEventDict = json.keyboardEventDict;
+        let flags = 0;
+
+        if (keyboardEventDict) {
+          if ('flags' in keyboardEventDict) {
+            flags = keyboardEventDict.flags;
+          }
+        } else {
+          // The naive way to figure out if the key to dispatch is printable.
+          let printable = !!json.charCode;
+
+          // For printable keys, the value should be the actual character.
+          // For non-printable keys, it should be a value in the D3E spec.
+          // Here we make some educated guess for it.
+          let key = printable ?
+              String.fromCharCode(json.charCode) :
+              guessKeyNameFromKeyCode(win.KeyboardEvent, json.keyCode);
+
+          // keyCode from content is only respected when the key is not an
+          // an alphanumeric character. We also ask TextInputProcessor not to
+          // infer this value for non-printable keys to keep the original
+          // behavior.
+          let keyCode = (printable && /^[a-zA-Z0-9]$/.test(key)) ?
+              key.toUpperCase().charCodeAt(0) :
+              json.keyCode;
+
+          keyboardEventDict = {
+            key: key,
+            keyCode: keyCode,
+            // We don't have any information to tell the virtual key the
+            // user have interacted with.
+            code: "",
+            // We do not have the information to infer location of the virtual key
+            // either (and we would need TextInputProcessor not to compute it).
+            location: 0,
+            // This indicates the key is triggered for repeats.
+            repeat: json.repeat
+          };
+
+          flags = tip.KEY_KEEP_KEY_LOCATION_STANDARD;
+          if (!printable) {
+            flags |= tip.KEY_NON_PRINTABLE_KEY;
+          }
+          if (!keyboardEventDict.keyCode) {
+            flags |= tip.KEY_KEEP_KEYCODE_ZERO;
+          }
+        }
+
+        let keyboardEvent = new win.KeyboardEvent("", keyboardEventDict);
+
+        let keydownDefaultPrevented = false;
+        try {
+          switch (json.method) {
+            case 'sendKey': {
+              let consumedFlags = tip.keydown(keyboardEvent, flags);
+              keydownDefaultPrevented =
+                !!(tip.KEYDOWN_IS_CONSUMED & consumedFlags);
+              if (!keyboardEventDict.repeat) {
+                tip.keyup(keyboardEvent, flags);
+              }
+              break;
+            }
+            case 'keydown': {
+              let consumedFlags = tip.keydown(keyboardEvent, flags);
+              keydownDefaultPrevented =
+                !!(tip.KEYDOWN_IS_CONSUMED & consumedFlags);
+              break;
+            }
+            case 'keyup': {
+              tip.keyup(keyboardEvent, flags);
+
+              break;
+            }
+          }
+        } catch (err) {
+          dump("forms.js:" + err.toString() + "\n");
+
+          if (json.requestId) {
+            if (err instanceof Ci.nsIException &&
+                err.result == Cr.NS_ERROR_ILLEGAL_VALUE) {
+              sendAsyncMessage("Forms:SendKey:Result:Error", {
+                requestId: json.requestId,
+                error: "The values specified are illegal."
+              });
+            } else {
+              sendAsyncMessage("Forms:SendKey:Result:Error", {
+                requestId: json.requestId,
+                error: "Unable to type into destroyed input."
+              });
+            }
+          }
+
+          break;
+        }
+
+        if (json.requestId) {
+          if (keydownDefaultPrevented) {
+            sendAsyncMessage("Forms:SendKey:Result:Error", {
+              requestId: json.requestId,
+              error: "Key event(s) was cancelled."
+            });
+          } else {
+            sendAsyncMessage("Forms:SendKey:Result:OK", {
+              requestId: json.requestId,
+              selectioninfo: this.getSelectionInfo()
+            });
+          }
+        }
+
+        break;
+
+      case "Forms:Select:Choice":
+        let options = target.options;
+        let valueChanged = false;
+        if ("index" in json) {
+          if (options.selectedIndex != json.index) {
+            options.selectedIndex = json.index;
+            valueChanged = true;
+          }
+        } else if ("indexes" in json) {
+          for (let i = 0; i < options.length; i++) {
+            let newValue = (json.indexes.indexOf(i) != -1);
+            if (options.item(i).selected != newValue) {
+              options.item(i).selected = newValue;
+              valueChanged = true;
+            }
+          }
+        }
+
+        // only fire onchange event if any selected option is changed
+        if (valueChanged) {
+          let event = target.ownerDocument.createEvent('HTMLEvents');
+          event.initEvent('change', true, true);
+          target.dispatchEvent(event);
+        }
+        break;
+
+      case "Forms:Select:Blur": {
+        if (this.focusedElement) {
+          this.focusedElement.blur();
+        }
+
+        break;
+      }
+
+      case "Forms:SetSelectionRange":  {
+        CompositionManager.endComposition('');
+
+        let start = json.selectionStart;
+        let end =  json.selectionEnd;
+
+        if (!setSelectionRange(target, start, end)) {
+          if (json.requestId) {
+            sendAsyncMessage("Forms:SetSelectionRange:Result:Error", {
+              requestId: json.requestId,
+              error: "failed"
+            });
+          }
+          break;
+        }
+
+        if (json.requestId) {
+          sendAsyncMessage("Forms:SetSelectionRange:Result:OK", {
+            requestId: json.requestId,
+            selectioninfo: this.getSelectionInfo()
+          });
+        }
+        break;
+      }
+
+      case "Forms:ReplaceSurroundingText": {
+        CompositionManager.endComposition('');
+
+        if (!replaceSurroundingText(target,
+                                    json.text,
+                                    json.offset,
+                                    json.length)) {
+          if (json.requestId) {
+            sendAsyncMessage("Forms:ReplaceSurroundingText:Result:Error", {
+              requestId: json.requestId,
+              error: "failed"
+            });
+          }
+          break;
+        }
+
+        if (json.requestId) {
+          sendAsyncMessage("Forms:ReplaceSurroundingText:Result:OK", {
+            requestId: json.requestId,
+            selectioninfo: this.getSelectionInfo()
+          });
+        }
+        break;
+      }
+
+      case "Forms:GetContext": {
+        let obj = getJSON(target, this._focusCounter);
+        sendAsyncMessage("Forms:GetContext:Result:OK", obj);
+        break;
+      }
+
+      case "Forms:SetComposition": {
+        CompositionManager.setComposition(target, json.text, json.cursor,
+                                          json.clauses, json.keyboardEventDict);
+        sendAsyncMessage("Forms:SetComposition:Result:OK", {
+          requestId: json.requestId,
+          selectioninfo: this.getSelectionInfo()
+        });
+        break;
+      }
+
+      case "Forms:EndComposition": {
+        CompositionManager.endComposition(json.text, json.keyboardEventDict);
+        sendAsyncMessage("Forms:EndComposition:Result:OK", {
+          requestId: json.requestId,
+          selectioninfo: this.getSelectionInfo()
+        });
+        break;
+      }
+    }
+    this._editing = false;
+
+  },
+
+  handleFocus: function fa_handleFocus(target) {
+    if (this.focusedElement === target)
+      return;
+
+    if (target instanceof HTMLOptionElement)
+      target = target.parentNode;
+
+    this.setFocusedElement(target);
+    this.sendInputState(target);
+    this.isHandlingFocus = true;
+  },
+
+  unhandleFocus: function fa_unhandleFocus() {
+    this.setFocusedElement(null);
+    this.isHandlingFocus = false;
+    this.selectionStart = -1;
+    this.selectionEnd = -1;
+    this.text = "";
+    sendAsyncMessage("Forms:Blur", {});
+  },
+
+  isFocusableElement: function fa_isFocusableElement(element) {
+    if (element instanceof HTMLSelectElement ||
+        element instanceof HTMLTextAreaElement)
+      return true;
+
+    if (element instanceof HTMLOptionElement &&
+        element.parentNode instanceof HTMLSelectElement)
+      return true;
+
+    return (element instanceof HTMLInputElement &&
+            !this.ignoredInputTypes.has(element.type) &&
+            !element.readOnly);
+  },
+
+  getTopLevelEditable: function fa_getTopLevelEditable(element) {
+    function retrieveTopLevelEditable(element) {
+      while (element && !isContentEditable(element))
+        element = element.parentNode;
+
+      return element;
+    }
+
+    return retrieveTopLevelEditable(element) || element;
+  },
+
+  sendInputState: function(element) {
+    sendAsyncMessage("Forms:Focus", getJSON(element, this._focusCounter));
+  },
+
+  getSelectionInfo: function fa_getSelectionInfo() {
+    let element = this.focusedElement;
+    let range =  getSelectionRange(element);
+
+    let text = isContentEditable(element) ? getContentEditableText(element)
+                                          : element.value;
+
+    let changed = this.selectionStart !== range[0] ||
+      this.selectionEnd !== range[1] ||
+      this.text !== text;
+
+    this.selectionStart = range[0];
+    this.selectionEnd = range[1];
+    this.text = text;
+
+    return {
+      selectionStart: range[0],
+      selectionEnd: range[1],
+      text: text,
+      changed: changed
+    };
+  },
+
+  _selectionTimeout: null,
+
+  // Notify when the selection range changes
+  updateSelection: function fa_updateSelection() {
+    // A call to setSelectionRange on input field causes 2 selection changes
+    // one to [0,0] and one to actual value. Both are sent in same tick.
+    // Prevent firing two events in that scenario, always only use the last 1.
+    //
+    // It is also a workaround for Bug 1053048, which prevents
+    // getSelectionInfo() accessing selectionStart or selectionEnd in the
+    // callback function of nsISelectionListener::NotifySelectionChanged().
+    if (this._selectionTimeout) {
+      content.clearTimeout(this._selectionTimeout);
+    }
+    this._selectionTimeout = content.setTimeout(function() {
+      if (!this.focusedElement) {
+        return;
+      }
+      let selectionInfo = this.getSelectionInfo();
+      if (selectionInfo.changed) {
+        sendAsyncMessage("Forms:SelectionChange", selectionInfo);
+      }
+    }.bind(this), 0);
+  }
+};
+
+FormAssistant.init();
+
+function isContentEditable(element) {
+  if (!element) {
+    return false;
+  }
+
+  if (element.isContentEditable || element.designMode == "on")
+    return true;
+
+  return element.ownerDocument && element.ownerDocument.designMode == "on";
+}
+
+function isPlainTextField(element) {
+  if (!element) {
+    return false;
+  }
+
+  return element instanceof HTMLTextAreaElement ||
+         (element instanceof HTMLInputElement &&
+          element.mozIsTextField(false));
+}
+
+function getJSON(element, focusCounter) {
+  // <input type=number> has a nested anonymous <input type=text> element that
+  // takes focus on behalf of the number control when someone tries to focus
+  // the number control. If |element| is such an anonymous text control then we
+  // need it's number control here in order to get the correct 'type' etc.:
+  element = element.ownerNumberControl || element;
+
+  let type = element.tagName.toLowerCase();
+  let inputType = (element.type || "").toLowerCase();
+  let value = element.value || "";
+  let max = element.max || "";
+  let min = element.min || "";
+
+  // Treat contenteditable element as a special text area field
+  if (isContentEditable(element)) {
+    type = "contenteditable";
+    inputType = "textarea";
+    value = getContentEditableText(element);
+  }
+
+  // Until the input type=date/datetime/range have been implemented
+  // let's return their real type even if the platform returns 'text'
+  let attributeInputType = element.getAttribute("type") || "";
+
+  if (attributeInputType) {
+    let inputTypeLowerCase = attributeInputType.toLowerCase();
+    switch (inputTypeLowerCase) {
+      case "datetime":
+      case "datetime-local":
+      case "month":
+      case "week":
+      case "range":
+        inputType = inputTypeLowerCase;
+        break;
+    }
+  }
+
+  // Gecko has some support for @inputmode but behind a preference and
+  // it is disabled by default.
+  // Gaia is then using @x-inputmode has its proprietary way to set
+  // inputmode for fields. This shouldn't be used outside of pre-installed
+  // apps because the attribute is going to disappear as soon as a definitive
+  // solution will be find.
+  let inputMode = element.getAttribute('x-inputmode');
+  if (inputMode) {
+    inputMode = inputMode.toLowerCase();
+  } else {
+    inputMode = '';
+  }
+
+  let range = getSelectionRange(element);
+
+  return {
+    "contextId": focusCounter,
+
+    "type": type,
+    "inputType": inputType,
+    "inputMode": inputMode,
+
+    "choices": getListForElement(element),
+    "value": value,
+    "selectionStart": range[0],
+    "selectionEnd": range[1],
+    "max": max,
+    "min": min,
+    "lang": element.lang || ""
+  };
+}
+
+function getListForElement(element) {
+  if (!(element instanceof HTMLSelectElement))
+    return null;
+
+  let optionIndex = 0;
+  let result = {
+    "multiple": element.multiple,
+    "choices": []
+  };
+
+  // Build up a flat JSON array of the choices.
+  // In HTML, it's possible for select element choices to be under a
+  // group header (but not recursively). We distinguish between headers
+  // and entries using the boolean "list.group".
+  let children = element.children;
+  for (let i = 0; i < children.length; i++) {
+    let child = children[i];
+
+    if (child instanceof HTMLOptGroupElement) {
+      result.choices.push({
+        "group": true,
+        "text": child.label || child.firstChild.data,
+        "disabled": child.disabled
+      });
+
+      let subchildren = child.children;
+      for (let j = 0; j < subchildren.length; j++) {
+        let subchild = subchildren[j];
+        result.choices.push({
+          "group": false,
+          "inGroup": true,
+          "text": subchild.text,
+          "disabled": child.disabled || subchild.disabled,
+          "selected": subchild.selected,
+          "optionIndex": optionIndex++
+        });
+      }
+    } else if (child instanceof HTMLOptionElement) {
+      result.choices.push({
+        "group": false,
+        "inGroup": false,
+        "text": child.text,
+        "disabled": child.disabled,
+        "selected": child.selected,
+        "optionIndex": optionIndex++
+      });
+    }
+  }
+
+  return result;
+};
+
+// Create a plain text document encode from the focused element.
+function getDocumentEncoder(element) {
+  let encoder = Cc["@mozilla.org/layout/documentEncoder;1?type=text/plain"]
+                .createInstance(Ci.nsIDocumentEncoder);
+  let flags = Ci.nsIDocumentEncoder.SkipInvisibleContent |
+              Ci.nsIDocumentEncoder.OutputRaw |
+              Ci.nsIDocumentEncoder.OutputDropInvisibleBreak |
+              // Bug 902847. Don't trim trailing spaces of a line.
+              Ci.nsIDocumentEncoder.OutputDontRemoveLineEndingSpaces |
+              Ci.nsIDocumentEncoder.OutputLFLineBreak |
+              Ci.nsIDocumentEncoder.OutputNonTextContentAsPlaceholder;
+  encoder.init(element.ownerDocument, "text/plain", flags);
+  return encoder;
+}
+
+// Get the visible content text of a content editable element
+function getContentEditableText(element) {
+  if (!element || !isContentEditable(element)) {
+    return null;
+  }
+
+  let doc = element.ownerDocument;
+  let range = doc.createRange();
+  range.selectNodeContents(element);
+  let encoder = FormAssistant.documentEncoder;
+  encoder.setRange(range);
+  return encoder.encodeToString();
+}
+
+function getSelectionRange(element) {
+  let start = 0;
+  let end = 0;
+  if (isPlainTextField(element)) {
+    // Get the selection range of <input> and <textarea> elements
+    start = element.selectionStart;
+    end = element.selectionEnd;
+  } else if (isContentEditable(element)){
+    // Get the selection range of contenteditable elements
+    let win = element.ownerDocument.defaultView;
+    let sel = win.getSelection();
+    if (sel && sel.rangeCount > 0) {
+      start = getContentEditableSelectionStart(element, sel);
+      end = start + getContentEditableSelectionLength(element, sel);
+    } else {
+      dump("Failed to get window.getSelection()\n");
+    }
+   }
+   return [start, end];
+ }
+
+function getContentEditableSelectionStart(element, selection) {
+  let doc = element.ownerDocument;
+  let range = doc.createRange();
+  range.setStart(element, 0);
+  range.setEnd(selection.anchorNode, selection.anchorOffset);
+  let encoder = FormAssistant.documentEncoder;
+  encoder.setRange(range);
+  return encoder.encodeToString().length;
+}
+
+function getContentEditableSelectionLength(element, selection) {
+  let encoder = FormAssistant.documentEncoder;
+  encoder.setRange(selection.getRangeAt(0));
+  return encoder.encodeToString().length;
+}
+
+function setSelectionRange(element, start, end) {
+  let isTextField = isPlainTextField(element);
+
+  // Check the parameters
+
+  if (!isTextField && !isContentEditable(element)) {
+    // Skip HTMLOptionElement and HTMLSelectElement elements, as they don't
+    // support the operation of setSelectionRange
+    return false;
+  }
+
+  let text = isTextField ? element.value : getContentEditableText(element);
+  let length = text.length;
+  if (start < 0) {
+    start = 0;
+  }
+  if (end > length) {
+    end = length;
+  }
+  if (start > end) {
+    start = end;
+  }
+
+  if (isTextField) {
+    // Set the selection range of <input> and <textarea> elements
+    element.setSelectionRange(start, end, "forward");
+    return true;
+  } else {
+    // set the selection range of contenteditable elements
+    let win = element.ownerDocument.defaultView;
+    let sel = win.getSelection();
+
+    // Move the caret to the start position
+    sel.collapse(element, 0);
+    for (let i = 0; i < start; i++) {
+      sel.modify("move", "forward", "character");
+    }
+
+    // Avoid entering infinite loop in case we cannot change the selection
+    // range. See bug https://bugzilla.mozilla.org/show_bug.cgi?id=978918
+    let oldStart = getContentEditableSelectionStart(element, sel);
+    let counter = 0;
+    while (oldStart < start) {
+      sel.modify("move", "forward", "character");
+      let newStart = getContentEditableSelectionStart(element, sel);
+      if (oldStart == newStart) {
+        counter++;
+        if (counter > MAX_BLOCKED_COUNT) {
+          return false;
+        }
+      } else {
+        counter = 0;
+        oldStart = newStart;
+      }
+    }
+
+    // Extend the selection to the end position
+    for (let i = start; i < end; i++) {
+      sel.modify("extend", "forward", "character");
+    }
+
+    // Avoid entering infinite loop in case we cannot change the selection
+    // range. See bug https://bugzilla.mozilla.org/show_bug.cgi?id=978918
+    counter = 0;
+    let selectionLength = end - start;
+    let oldSelectionLength = getContentEditableSelectionLength(element, sel);
+    while (oldSelectionLength  < selectionLength) {
+      sel.modify("extend", "forward", "character");
+      let newSelectionLength = getContentEditableSelectionLength(element, sel);
+      if (oldSelectionLength == newSelectionLength ) {
+        counter++;
+        if (counter > MAX_BLOCKED_COUNT) {
+          return false;
+        }
+      } else {
+        counter = 0;
+        oldSelectionLength = newSelectionLength;
+      }
+    }
+    return true;
+  }
+}
+
+/**
+ * Scroll the given element into view.
+ *
+ * Calls scrollSelectionIntoView for contentEditable elements.
+ */
+function scrollSelectionOrElementIntoView(element) {
+  let editor = getPlaintextEditor(element);
+  if (editor) {
+    editor.selectionController.scrollSelectionIntoView(
+      Ci.nsISelectionController.SELECTION_NORMAL,
+      Ci.nsISelectionController.SELECTION_FOCUS_REGION,
+      Ci.nsISelectionController.SCROLL_SYNCHRONOUS);
+  } else {
+      element.scrollIntoView(false);
+  }
+}
+
+// Get nsIPlaintextEditor object from an input field
+function getPlaintextEditor(element) {
+  let editor = null;
+  // Get nsIEditor
+  if (isPlainTextField(element)) {
+    // Get from the <input> and <textarea> elements
+    editor = element.QueryInterface(Ci.nsIDOMNSEditableElement).editor;
+  } else if (isContentEditable(element)) {
+    // Get from content editable element
+    let win = element.ownerDocument.defaultView;
+    let editingSession = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                            .getInterface(Ci.nsIWebNavigation)
+                            .QueryInterface(Ci.nsIInterfaceRequestor)
+                            .getInterface(Ci.nsIEditingSession);
+    if (editingSession) {
+      editor = editingSession.getEditorForWindow(win);
+    }
+  }
+  if (editor) {
+    editor.QueryInterface(Ci.nsIPlaintextEditor);
+  }
+  return editor;
+}
+
+function replaceSurroundingText(element, text, offset, length) {
+  let editor = FormAssistant.editor;
+  if (!editor) {
+    return false;
+  }
+
+  // Check the parameters.
+  if (length < 0) {
+    length = 0;
+  }
+
+  // Change selection range before replacing. For content editable element,
+  // searching the node for setting selection range is not needed when the
+  // selection is collapsed within a text node.
+  let fastPathHit = false;
+  if (!isPlainTextField(element)) {
+    let sel = element.ownerDocument.defaultView.getSelection();
+    let node = sel.anchorNode;
+    if (sel.isCollapsed && node && node.nodeType == 3 /* TEXT_NODE */) {
+      let start = sel.anchorOffset + offset;
+      let end = start + length;
+      // Fallback to setSelectionRange() if the replacement span multiple nodes.
+      if (start >= 0 && end <= node.textContent.length) {
+        fastPathHit = true;
+        sel.collapse(node, start);
+        sel.extend(node, end);
+      }
+    }
+  }
+  if (!fastPathHit) {
+    let range = getSelectionRange(element);
+    let start = range[0] + offset;
+    if (start < 0) {
+      start = 0;
+    }
+    let end = start + length;
+    if (start != range[0] || end != range[1]) {
+      if (!setSelectionRange(element, start, end)) {
+        return false;
+      }
+    }
+  }
+
+  if (length) {
+    // Delete the selected text.
+    editor.deleteSelection(Ci.nsIEditor.ePrevious, Ci.nsIEditor.eStrip);
+  }
+
+  if (text) {
+    // We don't use CR but LF
+    // see https://bugzilla.mozilla.org/show_bug.cgi?id=902847
+    text = text.replace(/\r/g, '\n');
+    // Insert the text to be replaced with.
+    editor.insertText(text);
+  }
+  return true;
+}
+
+var CompositionManager =  {
+  _isStarted: false,
+  _tip: null,
+  _KeyboardEventForWin: null,
+  _clauseAttrMap: {
+    'raw-input':
+      Ci.nsITextInputProcessor.ATTR_RAW_CLAUSE,
+    'selected-raw-text':
+      Ci.nsITextInputProcessor.ATTR_SELECTED_RAW_CLAUSE,
+    'converted-text':
+      Ci.nsITextInputProcessor.ATTR_CONVERTED_CLAUSE,
+    'selected-converted-text':
+      Ci.nsITextInputProcessor.ATTR_SELECTED_CLAUSE
+  },
+
+  setComposition: function cm_setComposition(element, text, cursor, clauses, dict) {
+    // Check parameters.
+    if (!element) {
+      return;
+    }
+    let len = text.length;
+    if (cursor > len) {
+      cursor = len;
+    }
+    let clauseLens = [];
+    let clauseAttrs = [];
+    if (clauses) {
+      let remainingLength = len;
+      for (let i = 0; i < clauses.length; i++) {
+        if (clauses[i]) {
+          let clauseLength = clauses[i].length || 0;
+          // Make sure the total clauses length is not bigger than that of the
+          // composition string.
+          if (clauseLength > remainingLength) {
+            clauseLength = remainingLength;
+          }
+          remainingLength -= clauseLength;
+          clauseLens.push(clauseLength);
+          clauseAttrs.push(this._clauseAttrMap[clauses[i].selectionType] ||
+                           Ci.nsITextInputProcessor.ATTR_RAW_CLAUSE);
+        }
+      }
+      // If the total clauses length is less than that of the composition
+      // string, extend the last clause to the end of the composition string.
+      if (remainingLength > 0) {
+        clauseLens[clauseLens.length - 1] += remainingLength;
+      }
+    } else {
+      clauseLens.push(len);
+      clauseAttrs.push(Ci.nsITextInputProcessor.ATTR_RAW_CLAUSE);
+    }
+
+    let win = element.ownerDocument.defaultView;
+    let tip = WindowMap.getTextInputProcessor(win);
+    if (!tip) {
+      return;
+    }
+    // Update the composing text.
+    tip.setPendingCompositionString(text);
+    for (var i = 0; i < clauseLens.length; i++) {
+      if (!clauseLens[i]) {
+        continue;
+      }
+      tip.appendClauseToPendingComposition(clauseLens[i], clauseAttrs[i]);
+    }
+    if (cursor >= 0) {
+      tip.setCaretInPendingComposition(cursor);
+    }
+
+    if (!dict) {
+      this._isStarted = tip.flushPendingComposition();
+    } else {
+      let keyboardEvent = new win.KeyboardEvent("", dict);
+      let flags = dict.flags;
+      this._isStarted = tip.flushPendingComposition(keyboardEvent, flags);
+    }
+
+    if (this._isStarted) {
+      this._tip = tip;
+      this._KeyboardEventForWin = win.KeyboardEvent;
+    }
+  },
+
+  endComposition: function cm_endComposition(text, dict) {
+    if (!this._isStarted) {
+      return;
+    }
+    let tip = this._tip;
+    if (!tip) {
+      return;
+    }
+
+    text = text || "";
+    if (!dict) {
+      tip.commitCompositionWith(text);
+    } else {
+      let keyboardEvent = new this._KeyboardEventForWin("", dict);
+      let flags = dict.flags;
+      tip.commitCompositionWith(text, keyboardEvent, flags);
+    }
+
+    this._isStarted = false;
+    this._tip = null;
+    this._KeyboardEventForWin = null;
+  },
+
+  // Composition ends due to external actions.
+  onCompositionEnd: function cm_onCompositionEnd() {
+    if (!this._isStarted) {
+      return;
+    }
+
+    this._isStarted = false;
+    this._tip = null;
+    this._KeyboardEventForWin = null;
+  }
+};