--- a/testing/marionette/browser.js
+++ b/testing/marionette/browser.js
@@ -2,16 +2,17 @@
  * 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";
 /* global frame */
 
 const {utils: Cu} = Components;
 
+const {WebElementEventTarget} = Cu.import("chrome://marionette/content/dom.js", {});
 Cu.import("chrome://marionette/content/element.js");
 const {
   NoSuchWindowError,
   UnsupportedOperationError,
 } = Cu.import("chrome://marionette/content/error.js", {});
 Cu.import("chrome://marionette/content/frame.js");
 
 this.EXPORTED_SYMBOLS = ["browser", "WindowState"];
@@ -132,16 +133,20 @@ browser.Context = class {
     } else if (this.tabBrowser &&
         this.driver.isReftestBrowser(this.tabBrowser)) {
       return this.tabBrowser;
     }
 
     return null;
   }
 
+  get messageManager() {
+    return this.contentBrowser.messageManager;
+  }
+
   /**
    * The current frame ID is managed per browser element on desktop in
    * case the ID needs to be refreshed. The currently selected window is
    * identified by a tab.
    */
   get curFrameId() {
     let rv = null;
     if (this.tab || this.driver.isReftestBrowser(this.contentBrowser)) {
@@ -326,16 +331,20 @@ browser.Context = class {
           // Firefox
           this.tabBrowser.selectedTab = this.tab;
 
         } else {
           throw new UnsupportedOperationError("switchToTab() not supported");
         }
       }
     }
+
+    // TODO(ato): Currently tied to curBrowser, but should be moved to
+    // WebElement when introduced by https://bugzil.la/1400256.
+    this.eventObserver = new WebElementEventTarget(this.messageManager);
   }
 
   /**
    * Registers a new frame, and sets its current frame id to this frame
    * if it is not already assigned, and if a) we already have a session
    * or b) we're starting a new session and it is the right start frame.
    *
    * @param {string} uid

new file mode 100644
--- /dev/null
+++ b/testing/marionette/dom.js
@@ -0,0 +1,203 @@
+/* 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 {utils: Cu} = Components;
+
+this.EXPORTED_SYMBOLS = [
+  "ContentEventObserverService",
+  "WebElementEventTarget",
+];
+
+/**
+ * The {@link EventTarget} for web elements can be used to observe DOM
+ * events in the content document.
+ *
+ * A caveat of the current implementation is that it is only possible
+ * to listen for top-level <code>window</code> global events.
+ *
+ * It needs to be backed by a {@link ContentEventObserverService} in a
+ * content frame script.
+ *
+ * Usage:
+ *
+ * <pre><code>
+ *     let observer = new WebElementEventTarget(messageManager);
+ *     await new Promise(resolve => {
+ *       observer.addEventListener("visibilitychange", resolve, {once: true});
+ *       chromeWindow.minimize();
+ *     });
+ * </code></pre>
+ */
+class WebElementEventTarget {
+  /**
+   * @param {function(): nsIMessageListenerManager} messageManagerFn
+   *     Message manager to the current browser.
+   */
+  constructor(messageManager) {
+    this.mm = messageManager;
+    this.listeners = {};
+    this.mm.addMessageListener("Marionette:DOM:OnEvent", this);
+  }
+
+  /**
+   * Register an event handler of a specific event type from the content
+   * frame.
+   *
+   * @param {string} type
+   *     Event type to listen for.
+   * @param {EventListener} listener
+   *     Object which receives a notification (a {@link BareEvent})
+   *     when an event of the specified type occurs.  This must be
+   *     an object implementing the {@link EventListener} interface,
+   *     or a JavaScript function.
+   * @param {boolean=} once
+   *     Indicates that the <var>listener</var> should be invoked at
+   *     most once after being added.  If true, the <var>listener</var>
+   *     would automatically be removed when invoked.
+   */
+  addEventListener(type, listener, {once = false} = {}) {
+    if (!(type in this.listeners)) {
+      this.listeners[type] = [];
+    }
+
+    if (!this.listeners[type].includes(listener)) {
+      listener.once = once;
+      this.listeners[type].push(listener);
+    }
+
+    this.mm.sendAsyncMessage("Marionette:DOM:AddEventListener", {type});
+  }
+
+  /**
+   * Removes an event listener.
+   *
+   * @param {string} type
+   *     Type of event to cease listening for.
+   * @param {EventListener} listener
+   *     Event handler to remove from the event target.
+   */
+  removeEventListener(type, listener) {
+    if (!(type in this.listeners)) {
+      return;
+    }
+
+    let stack = this.listeners[type];
+    for (let i = stack.length - 1; i >= 0; --i) {
+      if (stack[i] === listener) {
+        stack.splice(i, 1);
+        if (stack.length == 0) {
+          this.mm.sendAsyncMessage("Marionette:DOM:RemoveEventListener", {type});
+        }
+        return;
+      }
+    }
+  }
+
+  dispatchEvent(event) {
+    if (!(event.type in this.listeners)) {
+      return;
+    }
+
+    event.target = this;
+
+    let stack = this.listeners[event.type].slice(0);
+    stack.forEach(listener => {
+      listener.call(this, event);
+
+      if (listener.once) {
+        this.removeEventListener(event.type, listener);
+      }
+    });
+  }
+
+  receiveMessage({target, name, data, objects}) {
+    if (name != "Marionette:DOM:OnEvent") {
+      return;
+    }
+
+    let ev = {
+      type: data.type,
+      target: objects.target,
+    };
+    this.dispatchEvent(ev);
+  }
+}
+this.WebElementEventTarget = WebElementEventTarget;
+
+/**
+ * Provides the frame script backend for the
+ * {@link WebElementEventTarget}.
+ *
+ * This service receives requests for new DOM events to listen for and
+ * to cease listening for, and despatches IPC messages to the browser
+ * when they fire.
+ */
+class ContentEventObserverService {
+  /**
+   * @param {WindowProxy} windowGlobal
+   *     Window.
+   * @param {nsIMessageSender.sendAsyncMessage} sendAsyncMessage
+   *     Function for sending an async message to the parent browser.
+   */
+  constructor(windowGlobal, sendAsyncMessage) {
+    this.window = windowGlobal;
+    this.sendAsyncMessage = sendAsyncMessage;
+    this.events = new Set();
+  }
+
+  /**
+   * Observe a new DOM event.
+   *
+   * When the DOM event of <var>type</var> fires, a message is passed
+   * to the parent browser's event observer.
+   *
+   * If event type is already being observed, only a single message
+   * is sent.  E.g. multiple registration for events will only ever emit
+   * a maximum of one message.
+   *
+   * @param {string} type
+   *     DOM event to listen for.
+   */
+  add(type) {
+    if (this.events.has(type)) {
+      return;
+    }
+    this.window.addEventListener(type, this);
+    this.events.add(type);
+  }
+
+  /**
+   * Ceases observing a DOM event.
+   *
+   * @param {string} type
+   *     DOM event to stop listening for.
+   */
+  remove(type) {
+    if (!this.events.has(type)) {
+      return;
+    }
+    this.window.removeEventListener(type, this);
+    this.events.delete(type);
+  }
+
+  /** Ceases observing all previously registered DOM events. */
+  clear() {
+    for (let ev of this) {
+      this.remove(ev);
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (let ev of this.events) {
+      yield ev;
+    }
+  }
+
+  handleEvent({type, target}) {
+    this.sendAsyncMessage("Marionette:DOM:OnEvent", {type}, {target});
+  }
+}
+this.ContentEventObserverService = ContentEventObserverService;

--- a/testing/marionette/jar.mn
+++ b/testing/marionette/jar.mn
@@ -30,16 +30,17 @@ marionette.jar:
   content/assert.js (assert.js)
   content/addon.js (addon.js)
   content/session.js (session.js)
   content/transport.js (transport.js)
   content/packets.js (packets.js)
   content/stream-utils.js (stream-utils.js)
   content/reftest.js (reftest.js)
   content/reftest.xul (reftest.xul)
+  content/dom.js (dom.js)
 #ifdef ENABLE_TESTS
   content/test.xul (chrome/test.xul)
   content/test2.xul (chrome/test2.xul)
   content/test_dialog.dtd (chrome/test_dialog.dtd)
   content/test_dialog.properties (chrome/test_dialog.properties)
   content/test_dialog.xul (chrome/test_dialog.xul)
   content/test_nested_iframe.xul (chrome/test_nested_iframe.xul)
   content/test_anonymous_content.xul (chrome/test_anonymous_content.xul)

--- a/testing/marionette/listener.js
+++ b/testing/marionette/listener.js
@@ -35,16 +35,17 @@ const {
   InvalidSelectorError,
   NoSuchElementError,
   NoSuchFrameError,
   TimeoutError,
   UnknownError,
 } = Cu.import("chrome://marionette/content/error.js", {});
 Cu.import("chrome://marionette/content/evaluate.js");
 Cu.import("chrome://marionette/content/event.js");
+const {ContentEventObserverService} = Cu.import("chrome://marionette/content/dom.js", {});
 Cu.import("chrome://marionette/content/interaction.js");
 Cu.import("chrome://marionette/content/legacyaction.js");
 Cu.import("chrome://marionette/content/navigate.js");
 Cu.import("chrome://marionette/content/proxy.js");
 Cu.import("chrome://marionette/content/session.js");
 
 Cu.importGlobalProperties(["URL"]);
 
@@ -110,16 +111,19 @@ const modalHandler = function() {
   }
   curContainer = {frame: content, shadowRoot: null};
 };
 
 // sandbox storage and name of the current sandbox
 const sandboxes = new Sandboxes(() => curContainer.frame);
 let sandboxName = "default";
 
+const eventObservers = new ContentEventObserverService(
+    content, sendAsyncMessage.bind(this));
+
 /**
  * The load listener singleton helps to keep track of active page load
  * activities, and can be used by any command which might cause a navigation
  * to happen. In the specific case of a reload of the frame script it allows
  * to continue observing the current page load.
  */
 const loadListener = {
   commandID: null,
@@ -610,16 +614,18 @@ function startListeners() {
   addMessageListenerId("Marionette:clearElement", clearElementFn);
   addMessageListenerId("Marionette:switchToFrame", switchToFrame);
   addMessageListenerId("Marionette:switchToParentFrame", switchToParentFrame);
   addMessageListenerId("Marionette:switchToShadowRoot", switchToShadowRootFn);
   addMessageListenerId("Marionette:deleteSession", deleteSession);
   addMessageListenerId("Marionette:sleepSession", sleepSession);
   addMessageListenerId("Marionette:takeScreenshot", takeScreenshotFn);
   addMessageListenerId("Marionette:reftestWait", reftestWaitFn);
+  addMessageListener("Marionette:DOM:AddEventListener", domAddEventListener);
+  addMessageListener("Marionette:DOM:RemoveEventListener", domRemoveEventListener);
 }
 
 /**
  * Called when we start a new session. It registers the
  * current environment, and resets all values
  */
 function newSession(msg) {
   capabilities = session.Capabilities.fromJSON(msg.json);
@@ -1901,10 +1907,18 @@ async function reftestWait(url, remote) 
     flushRendering();
   }
 
   if (remote) {
     windowUtils.updateLayerTree();
   }
 }
 
+function domAddEventListener(msg) {
+  eventObservers.add(msg.json.type);
+}
+
+function domRemoveEventListener(msg) {
+  eventObservers.remove(msg.json.type);
+}
+
 // Call register self when we get loaded
 registerSelf();

new file mode 100644
--- /dev/null
+++ b/testing/marionette/test_dom.js
@@ -0,0 +1,278 @@
+const {utils: Cu} = Components;
+
+const {
+  ContentEventObserverService,
+  WebElementEventTarget,
+} = Cu.import("chrome://marionette/content/dom.js", {});
+
+class MessageSender {
+  constructor() {
+    this.listeners = {};
+    this.sent = [];
+  }
+
+  addMessageListener(name, listener) {
+    this.listeners[name] = listener;
+  }
+
+  sendAsyncMessage(name, data, objects) {
+    this.sent.push({name, data, objects});
+  }
+}
+
+class Window {
+  constructor() {
+    this.events = [];
+  }
+
+  addEventListener(type, listener) {
+    this.events.push(type);
+  }
+
+  removeEventListener(type, listener) {
+    for (let i = 0; i < this.events.length; ++i) {
+      if (this.events[i] === type) {
+        this.events.splice(i, 1);
+        return;
+      }
+    }
+  }
+}
+
+add_test(function test_WebElementEventTarget_addEventListener_init() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+  equal(Object.keys(eventTarget.listeners).length, 0);
+  equal(Object.keys(ipc.listeners).length, 1);
+
+  run_next_test();
+});
+
+add_test(function test_addEventListener() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  let listener = () => {};
+  eventTarget.addEventListener("click", listener);
+
+  // click listener was appended
+  equal(Object.keys(eventTarget.listeners).length, 1);
+  ok("click" in eventTarget.listeners);
+  equal(eventTarget.listeners["click"].length, 1);
+  equal(eventTarget.listeners["click"][0], listener);
+
+  // should have sent a registration message
+  deepEqual(
+      ipc.sent[0], {
+        name: "Marionette:DOM:AddEventListener",
+        data: {type: "click"},
+        objects: undefined,
+      });
+
+  run_next_test();
+});
+
+add_test(function test_addEventListener_sameReference() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  let listener = () => {};
+  eventTarget.addEventListener("click", listener);
+  eventTarget.addEventListener("click", listener);
+  equal(eventTarget.listeners["click"].length, 1);
+
+  run_next_test();
+});
+
+add_test(function test_WebElementEventTarget_addEventListener_once() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  eventTarget.addEventListener("click", () => {}, {once: true});
+  equal(eventTarget.listeners["click"][0].once, true);
+
+  eventTarget.dispatchEvent({type: "click"});
+  equal(eventTarget.listeners["click"].length, 0);
+  deepEqual(
+      ipc.sent[1], {
+        name: "Marionette:DOM:RemoveEventListener",
+        data: {type: "click"},
+        objects: undefined,
+      });
+
+  run_next_test();
+});
+
+add_test(function test_WebElementEventTarget_removeEventListener() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  equal(Object.keys(eventTarget.listeners).length, 0);
+  eventTarget.removeEventListener("click", () => {});
+  equal(Object.keys(eventTarget.listeners).length, 0);
+
+  let firstListener = () => {};
+  eventTarget.addEventListener("click", firstListener);
+  equal(eventTarget.listeners["click"].length, 1);
+  ok(eventTarget.listeners["click"][0] === firstListener);
+
+  let secondListener = () => {};
+  eventTarget.addEventListener("click", secondListener);
+  equal(eventTarget.listeners["click"].length, 2);
+  ok(eventTarget.listeners["click"][1] === secondListener);
+
+  ok(eventTarget.listeners["click"][0] !== eventTarget.listeners["click"][1]);
+
+  eventTarget.removeEventListener("click", secondListener);
+  equal(eventTarget.listeners["click"].length, 1);
+  ok(eventTarget.listeners["click"][0] === firstListener);
+
+  // event should not have been unregistered
+  // because there still exists another click event
+  equal(ipc.sent[ipc.sent.length - 1].name, "Marionette:DOM:AddEventListener");
+
+  eventTarget.removeEventListener("click", firstListener);
+  equal(eventTarget.listeners["click"].length, 0);
+  deepEqual(
+      ipc.sent[ipc.sent.length - 1],
+      {
+        name: "Marionette:DOM:RemoveEventListener",
+        data: {type: "click"},
+        objects: undefined,
+      });
+
+  run_next_test();
+});
+
+add_test(function test_WebElementEventTarget_dispatchEvent() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  let listenerCalled = false;
+  let listener = () => listenerCalled = true;
+  eventTarget.addEventListener("click", listener);
+  eventTarget.dispatchEvent({type: "click"});
+  ok(listenerCalled);
+
+  run_next_test();
+});
+
+add_test(function test_WebElementEventTarget_dispatchEvent_multipleListeners() {
+  let ipc = new MessageSender();
+  let eventTarget = new WebElementEventTarget(ipc);
+
+  let clicksA = 0;
+  let clicksB = 0;
+  let listenerA = () => ++clicksA;
+  let listenerB = () => ++clicksB;
+
+  // the same listener should only be added, and consequently fire, once
+  eventTarget.addEventListener("click", listenerA);
+  eventTarget.addEventListener("click", listenerA);
+  eventTarget.addEventListener("click", listenerB);
+  eventTarget.dispatchEvent({type: "click"});
+  equal(clicksA, 1);
+  equal(clicksB, 1);
+
+  run_next_test();
+});
+
+add_test(function test_ContentEventObserverService_add() {
+  let ipc = new MessageSender();
+  let win = new Window();
+  let obs = new ContentEventObserverService(
+      win, ipc.sendAsyncMessage.bind(ipc));
+
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  obs.add("foo");
+  equal(obs.events.size, 1);
+  equal(win.events.length, 1);
+  equal(obs.events.values().next().value, "foo");
+  equal(win.events[0], "foo");
+
+  obs.add("foo");
+  equal(obs.events.size, 1);
+  equal(win.events.length, 1);
+
+  run_next_test();
+});
+
+add_test(function test_ContentEventObserverService_remove() {
+  let ipc = new MessageSender();
+  let win = new Window();
+  let obs = new ContentEventObserverService(
+      win, ipc.sendAsyncMessage.bind(ipc));
+
+  obs.remove("foo");
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  obs.add("bar");
+  equal(obs.events.size, 1);
+  equal(win.events.length, 1);
+
+  obs.remove("bar");
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  obs.add("baz");
+  obs.add("baz");
+  equal(obs.events.size, 1);
+  equal(win.events.length, 1);
+
+  obs.add("bah");
+  equal(obs.events.size, 2);
+  equal(win.events.length, 2);
+
+  obs.remove("baz");
+  equal(obs.events.size, 1);
+  equal(win.events.length, 1);
+
+  obs.remove("bah");
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  run_next_test();
+});
+
+add_test(function test_ContentEventObserverService_clear() {
+  let ipc = new MessageSender();
+  let win = new Window();
+  let obs = new ContentEventObserverService(
+      win, ipc.sendAsyncMessage.bind(ipc));
+
+  obs.clear();
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  obs.add("foo");
+  obs.add("foo");
+  obs.add("bar");
+  equal(obs.events.size, 2);
+  equal(win.events.length, 2);
+
+  obs.clear();
+  equal(obs.events.size, 0);
+  equal(win.events.length, 0);
+
+  run_next_test();
+});
+
+add_test(function test_ContentEventObserverService_handleEvent() {
+  let ipc = new MessageSender();
+  let win = new Window();
+  let obs = new ContentEventObserverService(
+      win, ipc.sendAsyncMessage.bind(ipc));
+
+  obs.handleEvent({type: "click", target: win});
+  deepEqual(
+      ipc.sent[0], {
+        name: "Marionette:DOM:OnEvent",
+        data: {type: "click"},
+        objects: {"target": win},
+      });
+
+  run_next_test();
+});

--- a/testing/marionette/unit.ini
+++ b/testing/marionette/unit.ini
@@ -5,14 +5,15 @@
 # xpcshell unit tests for Marionette
 
 [DEFAULT]
 skip-if = appname == "thunderbird"
 
 [test_action.js]
 [test_assert.js]
 [test_cookie.js]
+[test_dom.js]
 [test_element.js]
 [test_error.js]
 [test_message.js]
 [test_navigate.js]
 [test_session.js]
 [test_wait.js]