Add m-esr52 at 52.6.0

1 files changed, 1255 insertions, 0 deletions

diff --git a/dom/inputmethod/MozKeyboard.js b/dom/inputmethod/MozKeyboard.js
new file mode 100644
index 000000000..3996f3e5d
--- /dev/null
+++ b/dom/inputmethod/MozKeyboard.js
@@ -0,0 +1,1255 @@
+/* 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";
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/DOMRequestHelper.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "cpmm",
+  "@mozilla.org/childprocessmessagemanager;1", "nsISyncMessageSender");
+
+XPCOMUtils.defineLazyServiceGetter(this, "tm",
+  "@mozilla.org/thread-manager;1", "nsIThreadManager");
+
+/*
+ * A WeakMap to map input method iframe window to
+ * it's active status, kbID, and ipcHelper.
+ */
+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 = {
+        active: false,
+        kbID: undefined,
+        ipcHelper: null
+      };
+      this._map.set(win, obj);
+
+      return obj;
+    }
+  },
+
+  /*
+   * Check if the given window is active.
+   */
+  isActive: function(win) {
+    if (!this._map || !win) {
+      return false;
+    }
+
+    return this._getObjForWin(win).active;
+  },
+
+  /*
+   * Set the active status of the given window.
+   */
+  setActive: function(win, isActive) {
+    if (!win) {
+      return;
+    }
+    let obj = this._getObjForWin(win);
+    obj.active = isActive;
+  },
+
+  /*
+   * Get the keyboard ID (assigned by Keyboard.jsm) of the given window.
+   */
+  getKbID: function(win) {
+    if (!this._map || !win) {
+      return undefined;
+    }
+
+    let obj = this._getObjForWin(win);
+    return obj.kbID;
+  },
+
+  /*
+   * Set the keyboard ID (assigned by Keyboard.jsm) of the given window.
+   */
+  setKbID: function(win, kbID) {
+    if (!win) {
+      return;
+    }
+    let obj = this._getObjForWin(win);
+    obj.kbID = kbID;
+  },
+
+  /*
+   * Get InputContextDOMRequestIpcHelper instance attached to this window.
+   */
+  getInputContextIpcHelper: function(win) {
+    if (!win) {
+      return;
+    }
+    let obj = this._getObjForWin(win);
+    if (!obj.ipcHelper) {
+      obj.ipcHelper = new InputContextDOMRequestIpcHelper(win);
+    }
+    return obj.ipcHelper;
+  },
+
+  /*
+   * Unset InputContextDOMRequestIpcHelper instance.
+   */
+  unsetInputContextIpcHelper: function(win) {
+    if (!win) {
+      return;
+    }
+    let obj = this._getObjForWin(win);
+    if (!obj.ipcHelper) {
+      return;
+    }
+    obj.ipcHelper = null;
+  }
+};
+
+var cpmmSendAsyncMessageWithKbID = function (self, msg, data) {
+  data.kbID = WindowMap.getKbID(self._window);
+  cpmm.sendAsyncMessage(msg, data);
+};
+
+/**
+ * ==============================================
+ * InputMethodManager
+ * ==============================================
+ */
+function MozInputMethodManager(win) {
+  this._window = win;
+}
+
+MozInputMethodManager.prototype = {
+  supportsSwitchingForCurrentInputContext: false,
+  _window: null,
+
+  classID: Components.ID("{7e9d7280-ef86-11e2-b778-0800200c9a66}"),
+
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  set oninputcontextfocus(handler) {
+    this.__DOM_IMPL__.setEventHandler("oninputcontextfocus", handler);
+  },
+
+  get oninputcontextfocus() {
+    return this.__DOM_IMPL__.getEventHandler("oninputcontextfocus");
+  },
+
+  set oninputcontextblur(handler) {
+    this.__DOM_IMPL__.setEventHandler("oninputcontextblur", handler);
+  },
+
+  get oninputcontextblur() {
+    return this.__DOM_IMPL__.getEventHandler("oninputcontextblur");
+  },
+
+  set onshowallrequest(handler) {
+    this.__DOM_IMPL__.setEventHandler("onshowallrequest", handler);
+  },
+
+  get onshowallrequest() {
+    return this.__DOM_IMPL__.getEventHandler("onshowallrequest");
+  },
+
+  set onnextrequest(handler) {
+    this.__DOM_IMPL__.setEventHandler("onnextrequest", handler);
+  },
+
+  get onnextrequest() {
+    return this.__DOM_IMPL__.getEventHandler("onnextrequest");
+  },
+
+  set onaddinputrequest(handler) {
+    this.__DOM_IMPL__.setEventHandler("onaddinputrequest", handler);
+  },
+
+  get onaddinputrequest() {
+    return this.__DOM_IMPL__.getEventHandler("onaddinputrequest");
+  },
+
+  set onremoveinputrequest(handler) {
+    this.__DOM_IMPL__.setEventHandler("onremoveinputrequest", handler);
+  },
+
+  get onremoveinputrequest() {
+    return this.__DOM_IMPL__.getEventHandler("onremoveinputrequest");
+  },
+
+  showAll: function() {
+    if (!WindowMap.isActive(this._window)) {
+      return;
+    }
+    cpmmSendAsyncMessageWithKbID(this, 'Keyboard:ShowInputMethodPicker', {});
+  },
+
+  next: function() {
+    if (!WindowMap.isActive(this._window)) {
+      return;
+    }
+    cpmmSendAsyncMessageWithKbID(this, 'Keyboard:SwitchToNextInputMethod', {});
+  },
+
+  supportsSwitching: function() {
+    if (!WindowMap.isActive(this._window)) {
+      return false;
+    }
+    return this.supportsSwitchingForCurrentInputContext;
+  },
+
+  hide: function() {
+    if (!WindowMap.isActive(this._window)) {
+      return;
+    }
+    cpmmSendAsyncMessageWithKbID(this, 'Keyboard:RemoveFocus', {});
+  },
+
+  setSupportsSwitchingTypes: function(types) {
+    cpmm.sendAsyncMessage('System:SetSupportsSwitchingTypes', {
+      types: types
+    });
+  },
+
+  handleFocus: function(data) {
+    let detail = new MozInputContextFocusEventDetail(this._window, data);
+    let wrappedDetail =
+      this._window.MozInputContextFocusEventDetail._create(this._window, detail);
+    let event = new this._window.CustomEvent('inputcontextfocus',
+      { cancelable: true, detail: wrappedDetail });
+
+    let handled = !this.__DOM_IMPL__.dispatchEvent(event);
+
+    // A gentle warning if the event is not preventDefault() by the content.
+    if (!handled) {
+      dump('MozKeyboard.js: A frame with input-manage permission did not' +
+        ' handle the inputcontextfocus event dispatched.\n');
+    }
+  },
+
+  handleBlur: function(data) {
+    let event =
+      new this._window.Event('inputcontextblur', { cancelable: true });
+
+    let handled = !this.__DOM_IMPL__.dispatchEvent(event);
+
+    // A gentle warning if the event is not preventDefault() by the content.
+    if (!handled) {
+      dump('MozKeyboard.js: A frame with input-manage permission did not' +
+        ' handle the inputcontextblur event dispatched.\n');
+    }
+  },
+
+  dispatchShowAllRequestEvent: function() {
+    this._fireSimpleEvent('showallrequest');
+  },
+
+  dispatchNextRequestEvent: function() {
+    this._fireSimpleEvent('nextrequest');
+  },
+
+  _fireSimpleEvent: function(eventType) {
+    let event = new this._window.Event(eventType);
+    let handled = !this.__DOM_IMPL__.dispatchEvent(event, { cancelable: true });
+
+    // A gentle warning if the event is not preventDefault() by the content.
+    if (!handled) {
+      dump('MozKeyboard.js: A frame with input-manage permission did not' +
+        ' handle the ' + eventType + ' event dispatched.\n');
+    }
+  },
+
+  handleAddInput: function(data) {
+    let p = this._fireInputRegistryEvent('addinputrequest', data);
+    if (!p) {
+      return;
+    }
+
+    p.then(() => {
+      cpmm.sendAsyncMessage('System:InputRegistry:Add:Done', {
+        id: data.id
+      });
+    }, (error) => {
+      cpmm.sendAsyncMessage('System:InputRegistry:Add:Done', {
+        id: data.id,
+        error: error || 'Unknown Error'
+      });
+    });
+  },
+
+  handleRemoveInput: function(data) {
+    let p = this._fireInputRegistryEvent('removeinputrequest', data);
+    if (!p) {
+      return;
+    }
+
+    p.then(() => {
+      cpmm.sendAsyncMessage('System:InputRegistry:Remove:Done', {
+        id: data.id
+      });
+    }, (error) => {
+      cpmm.sendAsyncMessage('System:InputRegistry:Remove:Done', {
+        id: data.id,
+        error: error || 'Unknown Error'
+      });
+    });
+  },
+
+  _fireInputRegistryEvent: function(eventType, data) {
+    let detail = new MozInputRegistryEventDetail(this._window, data);
+    let wrappedDetail =
+      this._window.MozInputRegistryEventDetail._create(this._window, detail);
+    let event = new this._window.CustomEvent(eventType,
+      { cancelable: true, detail: wrappedDetail });
+    let handled = !this.__DOM_IMPL__.dispatchEvent(event);
+
+    // A gentle warning if the event is not preventDefault() by the content.
+    if (!handled) {
+      dump('MozKeyboard.js: A frame with input-manage permission did not' +
+        ' handle the ' + eventType + ' event dispatched.\n');
+
+      return null;
+    }
+    return detail.takeChainedPromise();
+  }
+};
+
+function MozInputContextFocusEventDetail(win, data) {
+  this.type = data.type;
+  this.inputType = data.inputType;
+  this.value = data.value;
+  // Exposed as MozInputContextChoicesInfo dictionary defined in WebIDL
+  this.choices = data.choices;
+  this.min = data.min;
+  this.max = data.max;
+}
+MozInputContextFocusEventDetail.prototype = {
+  classID: Components.ID("{e0794208-ac50-40e8-b22e-6ee0b4c4e6e8}"),
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  type: undefined,
+  inputType: undefined,
+  value: '',
+  choices: null,
+  min: undefined,
+  max: undefined
+};
+
+function MozInputRegistryEventDetail(win, data) {
+  this._window = win;
+
+  this.manifestURL = data.manifestURL;
+  this.inputId = data.inputId;
+  // Exposed as MozInputMethodInputManifest dictionary defined in WebIDL
+  this.inputManifest = data.inputManifest;
+
+  this._chainedPromise = Promise.resolve();
+}
+MozInputRegistryEventDetail.prototype = {
+  classID: Components.ID("{02130070-9b3e-4f38-bbd9-f0013aa36717}"),
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  _window: null,
+
+  manifestURL: undefined,
+  inputId: undefined,
+  inputManifest: null,
+
+  waitUntil: function(p) {
+    // Need an extra protection here since waitUntil will be an no-op
+    // when chainedPromise is already returned.
+    if (!this._chainedPromise) {
+      throw new this._window.DOMException(
+        'Must call waitUntil() within the event handling loop.',
+        'InvalidStateError');
+    }
+
+    this._chainedPromise = this._chainedPromise
+      .then(function() { return p; });
+  },
+
+  takeChainedPromise: function() {
+    var p = this._chainedPromise;
+    this._chainedPromise = null;
+    return p;
+  }
+};
+
+/**
+ * ==============================================
+ * InputMethod
+ * ==============================================
+ */
+function MozInputMethod() { }
+
+MozInputMethod.prototype = {
+  __proto__: DOMRequestIpcHelper.prototype,
+
+  _window: null,
+  _inputcontext: null,
+  _wrappedInputContext: null,
+  _mgmt: null,
+  _wrappedMgmt: null,
+  _supportsSwitchingTypes: [],
+  _inputManageId: undefined,
+
+  classID: Components.ID("{4607330d-e7d2-40a4-9eb8-43967eae0142}"),
+
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsIDOMGlobalPropertyInitializer,
+    Ci.nsIObserver,
+    Ci.nsISupportsWeakReference
+  ]),
+
+  init: function mozInputMethodInit(win) {
+    this._window = win;
+    this._mgmt = new MozInputMethodManager(win);
+    this._wrappedMgmt = win.MozInputMethodManager._create(win, this._mgmt);
+    this.innerWindowID = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                            .getInterface(Ci.nsIDOMWindowUtils)
+                            .currentInnerWindowID;
+
+    Services.obs.addObserver(this, "inner-window-destroyed", false);
+
+    cpmm.addWeakMessageListener('Keyboard:Focus', this);
+    cpmm.addWeakMessageListener('Keyboard:Blur', this);
+    cpmm.addWeakMessageListener('Keyboard:SelectionChange', this);
+    cpmm.addWeakMessageListener('Keyboard:GetContext:Result:OK', this);
+    cpmm.addWeakMessageListener('Keyboard:SupportsSwitchingTypesChange', this);
+    cpmm.addWeakMessageListener('Keyboard:ReceiveHardwareKeyEvent', this);
+    cpmm.addWeakMessageListener('InputRegistry:Result:OK', this);
+    cpmm.addWeakMessageListener('InputRegistry:Result:Error', this);
+
+    if (this._hasInputManagePerm(win)) {
+      this._inputManageId = cpmm.sendSyncMessage('System:RegisterSync', {})[0];
+      cpmm.addWeakMessageListener('System:Focus', this);
+      cpmm.addWeakMessageListener('System:Blur', this);
+      cpmm.addWeakMessageListener('System:ShowAll', this);
+      cpmm.addWeakMessageListener('System:Next', this);
+      cpmm.addWeakMessageListener('System:InputRegistry:Add', this);
+      cpmm.addWeakMessageListener('System:InputRegistry:Remove', this);
+    }
+  },
+
+  uninit: function mozInputMethodUninit() {
+    this._window = null;
+    this._mgmt = null;
+    this._wrappedMgmt = null;
+
+    cpmm.removeWeakMessageListener('Keyboard:Focus', this);
+    cpmm.removeWeakMessageListener('Keyboard:Blur', this);
+    cpmm.removeWeakMessageListener('Keyboard:SelectionChange', this);
+    cpmm.removeWeakMessageListener('Keyboard:GetContext:Result:OK', this);
+    cpmm.removeWeakMessageListener('Keyboard:SupportsSwitchingTypesChange', this);
+    cpmm.removeWeakMessageListener('Keyboard:ReceiveHardwareKeyEvent', this);
+    cpmm.removeWeakMessageListener('InputRegistry:Result:OK', this);
+    cpmm.removeWeakMessageListener('InputRegistry:Result:Error', this);
+    this.setActive(false);
+
+    if (typeof this._inputManageId === 'number') {
+      cpmm.sendAsyncMessage('System:Unregister', {
+        'id': this._inputManageId
+      });
+      cpmm.removeWeakMessageListener('System:Focus', this);
+      cpmm.removeWeakMessageListener('System:Blur', this);
+      cpmm.removeWeakMessageListener('System:ShowAll', this);
+      cpmm.removeWeakMessageListener('System:Next', this);
+      cpmm.removeWeakMessageListener('System:InputRegistry:Add', this);
+      cpmm.removeWeakMessageListener('System:InputRegistry:Remove', this);
+    }
+  },
+
+  receiveMessage: function mozInputMethodReceiveMsg(msg) {
+    if (msg.name.startsWith('Keyboard') &&
+        !WindowMap.isActive(this._window)) {
+      return;
+    }
+
+    let data = msg.data;
+
+    if (msg.name.startsWith('System') &&
+      this._inputManageId !== data.inputManageId) {
+      return;
+    }
+    delete data.inputManageId;
+
+    let resolver = ('requestId' in data) ?
+      this.takePromiseResolver(data.requestId) : null;
+
+    switch(msg.name) {
+      case 'Keyboard:Focus':
+        // XXX Bug 904339 could receive 'text' event twice
+        this.setInputContext(data);
+        break;
+      case 'Keyboard:Blur':
+        this.setInputContext(null);
+        break;
+      case 'Keyboard:SelectionChange':
+        if (this.inputcontext) {
+          this._inputcontext.updateSelectionContext(data, false);
+        }
+        break;
+      case 'Keyboard:GetContext:Result:OK':
+        this.setInputContext(data);
+        break;
+      case 'Keyboard:SupportsSwitchingTypesChange':
+        this._supportsSwitchingTypes = data.types;
+        break;
+      case 'Keyboard:ReceiveHardwareKeyEvent':
+        if (!Ci.nsIHardwareKeyHandler) {
+          break;
+        }
+
+        let defaultPrevented = Ci.nsIHardwareKeyHandler.NO_DEFAULT_PREVENTED;
+
+        // |event.preventDefault()| is allowed to be called only when
+        // |event.cancelable| is true
+        if (this._inputcontext && data.keyDict.cancelable) {
+          defaultPrevented |= this._inputcontext.forwardHardwareKeyEvent(data);
+        }
+
+        cpmmSendAsyncMessageWithKbID(this, 'Keyboard:ReplyHardwareKeyEvent', {
+                                       type: data.type,
+                                       defaultPrevented: defaultPrevented
+                                     });
+        break;
+      case 'InputRegistry:Result:OK':
+        resolver.resolve();
+
+        break;
+
+      case 'InputRegistry:Result:Error':
+        resolver.reject(data.error);
+
+        break;
+
+      case 'System:Focus':
+        this._mgmt.handleFocus(data);
+        break;
+
+      case 'System:Blur':
+        this._mgmt.handleBlur(data);
+        break;
+
+      case 'System:ShowAll':
+        this._mgmt.dispatchShowAllRequestEvent();
+        break;
+
+      case 'System:Next':
+        this._mgmt.dispatchNextRequestEvent();
+        break;
+
+      case 'System:InputRegistry:Add':
+        this._mgmt.handleAddInput(data);
+        break;
+
+      case 'System:InputRegistry:Remove':
+        this._mgmt.handleRemoveInput(data);
+        break;
+    }
+  },
+
+  observe: function mozInputMethodObserve(subject, topic, data) {
+    let wId = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+    if (wId == this.innerWindowID)
+      this.uninit();
+  },
+
+  get mgmt() {
+    return this._wrappedMgmt;
+  },
+
+  get inputcontext() {
+    if (!WindowMap.isActive(this._window)) {
+      return null;
+    }
+    return this._wrappedInputContext;
+  },
+
+  set oninputcontextchange(handler) {
+    this.__DOM_IMPL__.setEventHandler("oninputcontextchange", handler);
+  },
+
+  get oninputcontextchange() {
+    return this.__DOM_IMPL__.getEventHandler("oninputcontextchange");
+  },
+
+  setInputContext: function mozKeyboardContextChange(data) {
+    if (this._inputcontext) {
+      this._inputcontext.destroy();
+      this._inputcontext = null;
+      this._wrappedInputContext = null;
+      this._mgmt.supportsSwitchingForCurrentInputContext = false;
+    }
+
+    if (data) {
+      this._mgmt.supportsSwitchingForCurrentInputContext =
+        (this._supportsSwitchingTypes.indexOf(data.inputType) !== -1);
+
+      this._inputcontext = new MozInputContext(data);
+      this._inputcontext.init(this._window);
+      // inputcontext will be exposed as a WebIDL object. Create its
+      // content-side object explicitly to avoid Bug 1001325.
+      this._wrappedInputContext =
+        this._window.MozInputContext._create(this._window, this._inputcontext);
+    }
+
+    let event = new this._window.Event("inputcontextchange");
+    this.__DOM_IMPL__.dispatchEvent(event);
+  },
+
+  setActive: function mozInputMethodSetActive(isActive) {
+    if (WindowMap.isActive(this._window) === isActive) {
+      return;
+    }
+
+    WindowMap.setActive(this._window, isActive);
+
+    if (isActive) {
+      // Activate current input method.
+      // If there is already an active context, then this will trigger
+      // a GetContext:Result:OK event, and we can initialize ourselves.
+      // Otherwise silently ignored.
+
+      // get keyboard ID from Keyboard.jsm,
+      // or if we already have it, get it from our map
+      // Note: if we need to get it from Keyboard.jsm,
+      // we have to use a synchronous message
+      var kbID = WindowMap.getKbID(this._window);
+      if (kbID) {
+        cpmmSendAsyncMessageWithKbID(this, 'Keyboard:RegisterSync', {});
+      } else {
+        let res = cpmm.sendSyncMessage('Keyboard:RegisterSync', {});
+        WindowMap.setKbID(this._window, res[0]);
+      }
+
+      cpmmSendAsyncMessageWithKbID(this, 'Keyboard:GetContext', {});
+    } else {
+      // Deactive current input method.
+      cpmmSendAsyncMessageWithKbID(this, 'Keyboard:Unregister', {});
+      if (this._inputcontext) {
+        this.setInputContext(null);
+      }
+    }
+  },
+
+  addInput: function(inputId, inputManifest) {
+    return this.createPromiseWithId(function(resolverId) {
+      let appId = this._window.document.nodePrincipal.appId;
+
+      cpmm.sendAsyncMessage('InputRegistry:Add', {
+        requestId: resolverId,
+        inputId: inputId,
+        inputManifest: inputManifest,
+        appId: appId
+      });
+    }.bind(this));
+  },
+
+  removeInput: function(inputId) {
+    return this.createPromiseWithId(function(resolverId) {
+      let appId = this._window.document.nodePrincipal.appId;
+
+      cpmm.sendAsyncMessage('InputRegistry:Remove', {
+        requestId: resolverId,
+        inputId: inputId,
+        appId: appId
+      });
+    }.bind(this));
+  },
+
+  setValue: function(value) {
+    cpmm.sendAsyncMessage('System:SetValue', {
+      'value': value
+    });
+  },
+
+  setSelectedOption: function(index) {
+    cpmm.sendAsyncMessage('System:SetSelectedOption', {
+      'index': index
+    });
+  },
+
+  setSelectedOptions: function(indexes) {
+    cpmm.sendAsyncMessage('System:SetSelectedOptions', {
+      'indexes': indexes
+    });
+  },
+
+  removeFocus: function() {
+    cpmm.sendAsyncMessage('System:RemoveFocus', {});
+  },
+
+  // Only the system app needs that, so instead of testing a permission which
+  // is allowed for all chrome:// url, we explicitly test that this is the
+  // system app's start URL.
+  _hasInputManagePerm: function(win) {
+    let url = win.location.href;
+    let systemAppIndex;
+    try {
+      systemAppIndex = Services.prefs.getCharPref('b2g.system_startup_url');
+    } catch(e) {
+      dump('MozKeyboard.jsm: no system app startup url set (pref is b2g.system_startup_url)');
+    }
+
+    dump(`MozKeyboard.jsm expecting ${systemAppIndex}\n`);
+    return url == systemAppIndex;
+  }
+};
+
+/**
+ * ==============================================
+ * InputContextDOMRequestIpcHelper
+ * ==============================================
+ */
+function InputContextDOMRequestIpcHelper(win) {
+  this.initDOMRequestHelper(win,
+    ["Keyboard:GetText:Result:OK",
+     "Keyboard:GetText:Result:Error",
+     "Keyboard:SetSelectionRange:Result:OK",
+     "Keyboard:ReplaceSurroundingText:Result:OK",
+     "Keyboard:SendKey:Result:OK",
+     "Keyboard:SendKey:Result:Error",
+     "Keyboard:SetComposition:Result:OK",
+     "Keyboard:EndComposition:Result:OK",
+     "Keyboard:SequenceError"]);
+}
+
+InputContextDOMRequestIpcHelper.prototype = {
+  __proto__: DOMRequestIpcHelper.prototype,
+  _inputContext: null,
+
+  attachInputContext: function(inputCtx) {
+    if (this._inputContext) {
+      throw new Error("InputContextDOMRequestIpcHelper: detach the context first.");
+    }
+
+    this._inputContext = inputCtx;
+  },
+
+  // Unset ourselves when the window is destroyed.
+  uninit: function() {
+    WindowMap.unsetInputContextIpcHelper(this._window);
+  },
+
+  detachInputContext: function() {
+    // All requests that are still pending need to be invalidated
+    // because the context is no longer valid.
+    this.forEachPromiseResolver(k => {
+      this.takePromiseResolver(k).reject("InputContext got destroyed");
+    });
+
+    this._inputContext = null;
+  },
+
+  receiveMessage: function(msg) {
+    if (!this._inputContext) {
+      dump('InputContextDOMRequestIpcHelper received message without context attached.\n');
+      return;
+    }
+
+    this._inputContext.receiveMessage(msg);
+  }
+};
+
+function MozInputContextSelectionChangeEventDetail(ctx, ownAction) {
+  this._ctx = ctx;
+  this.ownAction = ownAction;
+}
+
+MozInputContextSelectionChangeEventDetail.prototype = {
+  classID: Components.ID("ef35443e-a400-4ae3-9170-c2f4e05f7aed"),
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  ownAction: false,
+
+  get selectionStart() {
+    return this._ctx.selectionStart;
+  },
+
+  get selectionEnd() {
+    return this._ctx.selectionEnd;
+  }
+};
+
+function MozInputContextSurroundingTextChangeEventDetail(ctx, ownAction) {
+  this._ctx = ctx;
+  this.ownAction = ownAction;
+}
+
+MozInputContextSurroundingTextChangeEventDetail.prototype = {
+  classID: Components.ID("1c50fdaf-74af-4b2e-814f-792caf65a168"),
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  ownAction: false,
+
+  get text() {
+    return this._ctx.text;
+  },
+
+  get textBeforeCursor() {
+    return this._ctx.textBeforeCursor;
+  },
+
+  get textAfterCursor() {
+    return this._ctx.textAfterCursor;
+  }
+};
+
+/**
+ * ==============================================
+ * HardwareInput
+ * ==============================================
+ */
+function MozHardwareInput() {
+}
+
+MozHardwareInput.prototype = {
+  classID: Components.ID("{1e38633d-d08b-4867-9944-afa5c648adb6}"),
+  QueryInterface: XPCOMUtils.generateQI([]),
+};
+
+/**
+ * ==============================================
+ * InputContext
+ * ==============================================
+ */
+function MozInputContext(data) {
+  this._context = {
+    type: data.type,
+    inputType: data.inputType,
+    inputMode: data.inputMode,
+    lang: data.lang,
+    selectionStart: data.selectionStart,
+    selectionEnd: data.selectionEnd,
+    text: data.value
+  };
+
+  this._contextId = data.contextId;
+}
+
+MozInputContext.prototype = {
+  _window: null,
+  _context: null,
+  _contextId: -1,
+  _ipcHelper: null,
+  _hardwareinput: null,
+  _wrappedhardwareinput: null,
+
+  classID: Components.ID("{1e38633d-d08b-4867-9944-afa5c648adb6}"),
+
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsIObserver,
+    Ci.nsISupportsWeakReference
+  ]),
+
+  init: function ic_init(win) {
+    this._window = win;
+
+    this._ipcHelper = WindowMap.getInputContextIpcHelper(win);
+    this._ipcHelper.attachInputContext(this);
+    this._hardwareinput = new MozHardwareInput();
+    this._wrappedhardwareinput =
+      this._window.MozHardwareInput._create(this._window, this._hardwareinput);
+  },
+
+  destroy: function ic_destroy() {
+    // A consuming application might still hold a cached version of
+    // this object. After destroying all methods will throw because we
+    // cannot create new promises anymore, but we still hold
+    // (outdated) information in the context. So let's clear that out.
+    for (var k in this._context) {
+      if (this._context.hasOwnProperty(k)) {
+        this._context[k] = null;
+      }
+    }
+
+    this._ipcHelper.detachInputContext();
+    this._ipcHelper = null;
+
+    this._window = null;
+    this._hardwareinput = null;
+    this._wrappedhardwareinput = null;
+  },
+
+  receiveMessage: function ic_receiveMessage(msg) {
+    if (!msg || !msg.json) {
+      dump('InputContext received message without data\n');
+      return;
+    }
+
+    let json = msg.json;
+    let resolver = this._ipcHelper.takePromiseResolver(json.requestId);
+
+    if (!resolver) {
+      dump('InputContext received invalid requestId.\n');
+      return;
+    }
+
+    // Update context first before resolving promise to avoid race condition
+    if (json.selectioninfo) {
+      this.updateSelectionContext(json.selectioninfo, true);
+    }
+
+    switch (msg.name) {
+      case "Keyboard:SendKey:Result:OK":
+        resolver.resolve(true);
+        break;
+      case "Keyboard:SendKey:Result:Error":
+        resolver.reject(json.error);
+        break;
+      case "Keyboard:GetText:Result:OK":
+        resolver.resolve(json.text);
+        break;
+      case "Keyboard:GetText:Result:Error":
+        resolver.reject(json.error);
+        break;
+      case "Keyboard:SetSelectionRange:Result:OK":
+      case "Keyboard:ReplaceSurroundingText:Result:OK":
+        resolver.resolve(
+          Cu.cloneInto(json.selectioninfo, this._window));
+        break;
+      case "Keyboard:SequenceError":
+        // Occurs when a new element got focus, but the inputContext was
+        // not invalidated yet...
+        resolver.reject("InputContext has expired");
+        break;
+      case "Keyboard:SetComposition:Result:OK": // Fall through.
+      case "Keyboard:EndComposition:Result:OK":
+        resolver.resolve(true);
+        break;
+      default:
+        dump("Could not find a handler for " + msg.name);
+        resolver.reject();
+        break;
+    }
+  },
+
+  updateSelectionContext: function ic_updateSelectionContext(data, ownAction) {
+    if (!this._context) {
+      return;
+    }
+
+    let selectionDirty =
+      this._context.selectionStart !== data.selectionStart ||
+      this._context.selectionEnd !== data.selectionEnd;
+    let surroundDirty = selectionDirty || data.text !== this._contextId.text;
+
+    this._context.text = data.text;
+    this._context.selectionStart = data.selectionStart;
+    this._context.selectionEnd = data.selectionEnd;
+
+    if (selectionDirty) {
+      let selectionChangeDetail =
+        new MozInputContextSelectionChangeEventDetail(this, ownAction);
+      let wrappedSelectionChangeDetail =
+        this._window.MozInputContextSelectionChangeEventDetail
+          ._create(this._window, selectionChangeDetail);
+      let selectionChangeEvent = new this._window.CustomEvent("selectionchange",
+        { cancelable: false, detail: wrappedSelectionChangeDetail });
+
+      this.__DOM_IMPL__.dispatchEvent(selectionChangeEvent);
+    }
+
+    if (surroundDirty) {
+      let surroundingTextChangeDetail =
+        new MozInputContextSurroundingTextChangeEventDetail(this, ownAction);
+      let wrappedSurroundingTextChangeDetail =
+        this._window.MozInputContextSurroundingTextChangeEventDetail
+          ._create(this._window, surroundingTextChangeDetail);
+      let selectionChangeEvent = new this._window.CustomEvent("surroundingtextchange",
+        { cancelable: false, detail: wrappedSurroundingTextChangeDetail });
+
+      this.__DOM_IMPL__.dispatchEvent(selectionChangeEvent);
+    }
+  },
+
+  // tag name of the input field
+  get type() {
+    return this._context.type;
+  },
+
+  // type of the input field
+  get inputType() {
+    return this._context.inputType;
+  },
+
+  get inputMode() {
+    return this._context.inputMode;
+  },
+
+  get lang() {
+    return this._context.lang;
+  },
+
+  getText: function ic_getText(offset, length) {
+    let text;
+    if (offset && length) {
+      text = this._context.text.substr(offset, length);
+    } else if (offset) {
+      text = this._context.text.substr(offset);
+    } else {
+      text = this._context.text;
+    }
+
+    return this._window.Promise.resolve(text);
+  },
+
+  get selectionStart() {
+    return this._context.selectionStart;
+  },
+
+  get selectionEnd() {
+    return this._context.selectionEnd;
+  },
+
+  get text() {
+    return this._context.text;
+  },
+
+  get textBeforeCursor() {
+    let text = this._context.text;
+    let start = this._context.selectionStart;
+    return (start < 100) ?
+      text.substr(0, start) :
+      text.substr(start - 100, 100);
+  },
+
+  get textAfterCursor() {
+    let text = this._context.text;
+    let start = this._context.selectionStart;
+    let end = this._context.selectionEnd;
+    return text.substr(start, end - start + 100);
+  },
+
+  get hardwareinput() {
+    return this._wrappedhardwareinput;
+  },
+
+  setSelectionRange: function ic_setSelectionRange(start, length) {
+    let self = this;
+    return this._sendPromise(function(resolverId) {
+      cpmmSendAsyncMessageWithKbID(self, 'Keyboard:SetSelectionRange', {
+        contextId: self._contextId,
+        requestId: resolverId,
+        selectionStart: start,
+        selectionEnd: start + length
+      });
+    });
+  },
+
+  get onsurroundingtextchange() {
+    return this.__DOM_IMPL__.getEventHandler("onsurroundingtextchange");
+  },
+
+  set onsurroundingtextchange(handler) {
+    this.__DOM_IMPL__.setEventHandler("onsurroundingtextchange", handler);
+  },
+
+  get onselectionchange() {
+    return this.__DOM_IMPL__.getEventHandler("onselectionchange");
+  },
+
+  set onselectionchange(handler) {
+    this.__DOM_IMPL__.setEventHandler("onselectionchange", handler);
+  },
+
+  replaceSurroundingText: function ic_replaceSurrText(text, offset, length) {
+    let self = this;
+    return this._sendPromise(function(resolverId) {
+      cpmmSendAsyncMessageWithKbID(self, 'Keyboard:ReplaceSurroundingText', {
+        contextId: self._contextId,
+        requestId: resolverId,
+        text: text,
+        offset: offset || 0,
+        length: length || 0
+      });
+    });
+  },
+
+  deleteSurroundingText: function ic_deleteSurrText(offset, length) {
+    return this.replaceSurroundingText(null, offset, length);
+  },
+
+  sendKey: function ic_sendKey(dictOrKeyCode, charCode, modifiers, repeat) {
+    if (typeof dictOrKeyCode === 'number') {
+      // XXX: modifiers are ignored in this API method.
+
+      return this._sendPromise((resolverId) => {
+        cpmmSendAsyncMessageWithKbID(this, 'Keyboard:SendKey', {
+          contextId: this._contextId,
+          requestId: resolverId,
+          method: 'sendKey',
+          keyCode: dictOrKeyCode,
+          charCode: charCode,
+          repeat: repeat
+        });
+      });
+    } else if (typeof dictOrKeyCode === 'object') {
+      return this._sendPromise((resolverId) => {
+        cpmmSendAsyncMessageWithKbID(this, 'Keyboard:SendKey', {
+          contextId: this._contextId,
+          requestId: resolverId,
+          method: 'sendKey',
+          keyboardEventDict: this._getkeyboardEventDict(dictOrKeyCode)
+        });
+      });
+    } else {
+      // XXX: Should not reach here; implies WebIDL binding error.
+      throw new TypeError('Unknown argument passed.');
+    }
+  },
+
+  keydown: function ic_keydown(dict) {
+    return this._sendPromise((resolverId) => {
+      cpmmSendAsyncMessageWithKbID(this, 'Keyboard:SendKey', {
+        contextId: this._contextId,
+         requestId: resolverId,
+        method: 'keydown',
+        keyboardEventDict: this._getkeyboardEventDict(dict)
+       });
+     });
+   },
+
+  keyup: function ic_keyup(dict) {
+    return this._sendPromise((resolverId) => {
+      cpmmSendAsyncMessageWithKbID(this, 'Keyboard:SendKey', {
+        contextId: this._contextId,
+        requestId: resolverId,
+        method: 'keyup',
+        keyboardEventDict: this._getkeyboardEventDict(dict)
+      });
+    });
+  },
+
+  setComposition: function ic_setComposition(text, cursor, clauses, dict) {
+    let self = this;
+    return this._sendPromise((resolverId) => {
+      cpmmSendAsyncMessageWithKbID(self, 'Keyboard:SetComposition', {
+        contextId: self._contextId,
+        requestId: resolverId,
+        text: text,
+        cursor: (typeof cursor !== 'undefined') ? cursor : text.length,
+        clauses: clauses || null,
+        keyboardEventDict: this._getkeyboardEventDict(dict)
+      });
+    });
+  },
+
+  endComposition: function ic_endComposition(text, dict) {
+    let self = this;
+    return this._sendPromise((resolverId) => {
+      cpmmSendAsyncMessageWithKbID(self, 'Keyboard:EndComposition', {
+        contextId: self._contextId,
+        requestId: resolverId,
+        text: text || '',
+        keyboardEventDict: this._getkeyboardEventDict(dict)
+      });
+    });
+  },
+
+  // Generate a new keyboard event by the received keyboard dictionary
+  // and return defaultPrevented's result of the event after dispatching.
+  forwardHardwareKeyEvent: function ic_forwardHardwareKeyEvent(data) {
+    if (!Ci.nsIHardwareKeyHandler) {
+      return;
+    }
+
+    if (!this._context) {
+      return Ci.nsIHardwareKeyHandler.NO_DEFAULT_PREVENTED;
+    }
+    let evt = new this._window.KeyboardEvent(data.type,
+                                             Cu.cloneInto(data.keyDict,
+                                                          this._window));
+    this._hardwareinput.__DOM_IMPL__.dispatchEvent(evt);
+    return this._getDefaultPreventedValue(evt);
+  },
+
+  _getDefaultPreventedValue: function(evt) {
+    if (!Ci.nsIHardwareKeyHandler) {
+      return;
+    }
+
+    let flags = Ci.nsIHardwareKeyHandler.NO_DEFAULT_PREVENTED;
+
+    if (evt.defaultPrevented) {
+      flags |= Ci.nsIHardwareKeyHandler.DEFAULT_PREVENTED;
+    }
+
+    if (evt.defaultPreventedByChrome) {
+      flags |= Ci.nsIHardwareKeyHandler.DEFAULT_PREVENTED_BY_CHROME;
+    }
+
+    if (evt.defaultPreventedByContent) {
+      flags |= Ci.nsIHardwareKeyHandler.DEFAULT_PREVENTED_BY_CONTENT;
+    }
+
+    return flags;
+  },
+
+  _sendPromise: function(callback) {
+    let self = this;
+    return this._ipcHelper.createPromiseWithId(function(aResolverId) {
+      if (!WindowMap.isActive(self._window)) {
+        self._ipcHelper.removePromiseResolver(aResolverId);
+        reject('Input method is not active.');
+        return;
+      }
+      callback(aResolverId);
+    });
+  },
+
+  // Take a MozInputMethodKeyboardEventDict dict, creates a keyboardEventDict
+  // object that can be sent to forms.js
+  _getkeyboardEventDict: function(dict) {
+    if (typeof dict !== 'object' || !dict.key) {
+      return;
+    }
+
+    var keyboardEventDict = {
+      key: dict.key,
+      code: dict.code,
+      repeat: dict.repeat,
+      flags: 0
+    };
+
+    if (dict.printable) {
+      keyboardEventDict.flags |=
+        Ci.nsITextInputProcessor.KEY_FORCE_PRINTABLE_KEY;
+    }
+
+    if (/^[a-zA-Z0-9]$/.test(dict.key)) {
+      // keyCode must follow the key value in this range;
+      // disregard the keyCode from content.
+      keyboardEventDict.keyCode = dict.key.toUpperCase().charCodeAt(0);
+    } else if (typeof dict.keyCode === 'number') {
+      // Allow keyCode to be specified for other key values.
+      keyboardEventDict.keyCode = dict.keyCode;
+
+      // Allow keyCode to be explicitly set to zero.
+      if (dict.keyCode === 0) {
+        keyboardEventDict.flags |=
+          Ci.nsITextInputProcessor.KEY_KEEP_KEYCODE_ZERO;
+      }
+    }
+
+    return keyboardEventDict;
+  }
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([MozInputMethod]);