Add m-esr52 at 52.6.0

1 files changed, 260 insertions, 0 deletions

diff --git a/testing/marionette/frame.js b/testing/marionette/frame.js
new file mode 100644
index 000000000..fc713eb97
--- /dev/null
+++ b/testing/marionette/frame.js
@@ -0,0 +1,260 @@
+/* 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 {classes: Cc, interfaces: Ci, results: Cr, utils: Cu} = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+this.EXPORTED_SYMBOLS = ["frame"];
+
+this.frame = {};
+
+const FRAME_SCRIPT = "chrome://marionette/content/listener.js";
+
+// list of OOP frames that has the frame script loaded
+var remoteFrames = [];
+
+/**
+ * An object representing a frame that Marionette has loaded a
+ * frame script in.
+ */
+frame.RemoteFrame = function (windowId, frameId) {
+  // outerWindowId relative to main process
+  this.windowId = windowId;
+  // actual frame relative to the windowId's frames list
+  this.frameId = frameId;
+  // assigned frame ID, used for messaging
+  this.targetFrameId = this.frameId;
+  // list of OOP frames that has the frame script loaded
+  this.remoteFrames = [];
+};
+
+/**
+ * The FrameManager will maintain the list of Out Of Process (OOP)
+ * frames and will handle frame switching between them.
+ *
+ * It handles explicit frame switching (switchToFrame), and implicit
+ * frame switching, which occurs when a modal dialog is triggered in B2G.
+ *
+ * @param {GeckoDriver} driver
+ *     Reference to the driver instance.
+ */
+frame.Manager = class {
+  constructor(driver) {
+    // messageManager maintains the messageManager
+    // for the current process' chrome frame or the global message manager
+
+    // holds a member of the remoteFrames (for an OOP frame)
+    // or null (for the main process)
+    this.currentRemoteFrame = null;
+    // frame we'll need to restore once interrupt is gone
+    this.previousRemoteFrame = null;
+    // set to true when we have been interrupted by a modal
+    this.handledModal = false;
+    this.driver = driver;
+  }
+
+  /**
+   * Receives all messages from content messageManager.
+   */
+  receiveMessage(message) {
+    switch (message.name) {
+      case "MarionetteFrame:getInterruptedState":
+        // this will return true if the calling frame was interrupted by a modal dialog
+        if (this.previousRemoteFrame) {
+          // get the frame window of the interrupted frame
+          let interruptedFrame = Services.wm.getOuterWindowWithId(
+              this.previousRemoteFrame.windowId);
+
+          if (this.previousRemoteFrame.frameId !== null) {
+            // find OOP frame
+            let iframes = interruptedFrame.document.getElementsByTagName("iframe");
+            interruptedFrame = iframes[this.previousRemoteFrame.frameId];
+          }
+
+          // check if the interrupted frame is the same as the calling frame
+          if (interruptedFrame.src == message.target.src) {
+            return {value: this.handledModal};
+          }
+
+        // we get here if previousRemoteFrame and currentRemoteFrame are null,
+        // i.e. if we're in a non-OOP process, or we haven't switched into an OOP frame,
+        // in which case, handledModal can't be set to true
+        } else if (this.currentRemoteFrame === null) {
+          return {value: this.handledModal};
+        }
+        return {value: false};
+
+      // handleModal is called when we need to switch frames to the main
+      // process due to a modal dialog interrupt
+      case "MarionetteFrame:handleModal":
+        // If previousRemoteFrame was set, that means we switched into a
+        // remote frame.  If this is the case, then we want to switch back
+        // into the system frame.  If it isn't the case, then we're in a
+        // non-OOP environment, so we don't need to handle remote frames.
+        let isLocal = true;
+        if (this.currentRemoteFrame !== null) {
+          isLocal = false;
+          this.removeMessageManagerListeners(
+              this.currentRemoteFrame.messageManager.get());
+
+          // store the previous frame so we can switch back to it when
+          // the modal is dismissed
+          this.previousRemoteFrame = this.currentRemoteFrame;
+
+          // by setting currentRemoteFrame to null,
+          // it signifies we're in the main process
+          this.currentRemoteFrame = null;
+          this.driver.messageManager = Cc["@mozilla.org/globalmessagemanager;1"]
+              .getService(Ci.nsIMessageBroadcaster);
+        }
+
+        this.handledModal = true;
+        this.driver.sendOk(this.driver.command_id);
+        return {value: isLocal};
+
+      case "MarionetteFrame:getCurrentFrameId":
+        if (this.currentRemoteFrame !== null) {
+          return this.currentRemoteFrame.frameId;
+        }
+    }
+  }
+
+  getOopFrame(winId, frameId) {
+    // get original frame window
+    let outerWin = Services.wm.getOuterWindowWithId(winId);
+    // find the OOP frame
+    let f = outerWin.document.getElementsByTagName("iframe")[frameId];
+    return f;
+  }
+
+  getFrameMM(winId, frameId) {
+    let oopFrame = this.getOopFrame(winId, frameId);
+    let mm = oopFrame.QueryInterface(Ci.nsIFrameLoaderOwner)
+        .frameLoader.messageManager;
+    return mm;
+  }
+
+  /**
+   * Switch to OOP frame.  We're handling this here so we can maintain
+   * a list of remote frames.
+   */
+  switchToFrame(winId, frameId) {
+    let oopFrame = this.getOopFrame(winId, frameId);
+    let mm = this.getFrameMM(winId, frameId);
+
+    // see if this frame already has our frame script loaded in it;
+    // if so, just wake it up
+    for (let i = 0; i < remoteFrames.length; i++) {
+      let f = remoteFrames[i];
+      let fmm = f.messageManager.get();
+      try {
+        fmm.sendAsyncMessage("aliveCheck", {});
+      } catch (e) {
+        if (e.result == Cr.NS_ERROR_NOT_INITIALIZED) {
+          remoteFrames.splice(i--, 1);
+          continue;
+        }
+      }
+
+      if (fmm == mm) {
+        this.currentRemoteFrame = f;
+        this.addMessageManagerListeners(mm);
+
+        mm.sendAsyncMessage("Marionette:restart");
+        return oopFrame.id;
+      }
+    }
+
+    // if we get here, then we need to load the frame script in this frame,
+    // and set the frame's ChromeMessageSender as the active message manager
+    // the driver will listen to.
+    this.addMessageManagerListeners(mm);
+    let f = new frame.RemoteFrame(winId, frameId);
+    f.messageManager = Cu.getWeakReference(mm);
+    remoteFrames.push(f);
+    this.currentRemoteFrame = f;
+
+    mm.loadFrameScript(FRAME_SCRIPT, true, true);
+
+    return oopFrame.id;
+  }
+
+  /*
+   * This function handles switching back to the frame that was
+   * interrupted by the modal dialog.  It gets called by the interrupted
+   * frame once the dialog is dismissed and the frame resumes its process.
+   */
+  switchToModalOrigin() {
+    // only handle this if we indeed switched out of the modal's
+    // originating frame
+    if (this.previousRemoteFrame !== null) {
+      this.currentRemoteFrame = this.previousRemoteFrame;
+      let mm = this.currentRemoteFrame.messageManager.get();
+      this.addMessageManagerListeners(mm);
+    }
+    this.handledModal = false;
+  }
+
+  /**
+   * Adds message listeners to the driver,  listening for
+   * messages from content frame scripts.  It also adds a
+   * MarionetteFrame:getInterruptedState message listener to the
+   * FrameManager, so the frame manager's state can be checked by the frame.
+   *
+   * @param {nsIMessageListenerManager} mm
+   *     The message manager object, typically
+   *     ChromeMessageBroadcaster or ChromeMessageSender.
+   */
+  addMessageManagerListeners(mm) {
+    mm.addWeakMessageListener("Marionette:ok", this.driver);
+    mm.addWeakMessageListener("Marionette:done", this.driver);
+    mm.addWeakMessageListener("Marionette:error", this.driver);
+    mm.addWeakMessageListener("Marionette:emitTouchEvent", this.driver);
+    mm.addWeakMessageListener("Marionette:log", this.driver);
+    mm.addWeakMessageListener("Marionette:shareData", this.driver);
+    mm.addWeakMessageListener("Marionette:switchToModalOrigin", this.driver);
+    mm.addWeakMessageListener("Marionette:switchedToFrame", this.driver);
+    mm.addWeakMessageListener("Marionette:getVisibleCookies", this.driver);
+    mm.addWeakMessageListener("Marionette:getImportedScripts", this.driver.importedScripts);
+    mm.addWeakMessageListener("Marionette:register", this.driver);
+    mm.addWeakMessageListener("Marionette:listenersAttached", this.driver);
+    mm.addWeakMessageListener("MarionetteFrame:handleModal", this);
+    mm.addWeakMessageListener("MarionetteFrame:getCurrentFrameId", this);
+    mm.addWeakMessageListener("MarionetteFrame:getInterruptedState", this);
+  }
+
+  /**
+   * Removes listeners for messages from content frame scripts.
+   * We do not remove the MarionetteFrame:getInterruptedState or
+   * the Marionette:switchToModalOrigin message listener, because we
+   * want to allow all known frames to contact the frame manager so
+   * that it can check if it was interrupted, and if so, it will call
+   * switchToModalOrigin when its process gets resumed.
+   *
+   * @param {nsIMessageListenerManager} mm
+   *     The message manager object, typically
+   *     ChromeMessageBroadcaster or ChromeMessageSender.
+   */
+  removeMessageManagerListeners(mm) {
+    mm.removeWeakMessageListener("Marionette:ok", this.driver);
+    mm.removeWeakMessageListener("Marionette:done", this.driver);
+    mm.removeWeakMessageListener("Marionette:error", this.driver);
+    mm.removeWeakMessageListener("Marionette:log", this.driver);
+    mm.removeWeakMessageListener("Marionette:shareData", this.driver);
+    mm.removeWeakMessageListener("Marionette:switchedToFrame", this.driver);
+    mm.removeWeakMessageListener("Marionette:getVisibleCookies", this.driver);
+    mm.removeWeakMessageListener("Marionette:getImportedScripts", this.driver.importedScripts);
+    mm.removeWeakMessageListener("Marionette:listenersAttached", this.driver);
+    mm.removeWeakMessageListener("Marionette:register", this.driver);
+    mm.removeWeakMessageListener("MarionetteFrame:handleModal", this);
+    mm.removeWeakMessageListener("MarionetteFrame:getCurrentFrameId", this);
+  }
+};
+
+frame.Manager.prototype.QueryInterface = XPCOMUtils.generateQI(
+    [Ci.nsIMessageListener, Ci.nsISupportsWeakReference]);