Separate out bridge code into parent/child/bridge/common

Author: Daniel Brain

src/bridge/bridge.js

@@ -0,0 +1,33 @@
+
+import { CONSTANTS } from '../conf';
+import { getParent, isWindowClosed } from '../lib';
+import { global } from '../global';
+import { send } from '../interface';
+
+global.openTunnelToParent = function openTunnelToParent({ name, source, canary, sendMessage }) {
+
+    let remoteWindow = getParent(window);
+
+    if (!remoteWindow) {
+        throw new Error(`No parent window found to open tunnel to`);
+    }
+
+    return send(remoteWindow, CONSTANTS.POST_MESSAGE_NAMES.OPEN_TUNNEL, {
+        name,
+        sendMessage() {
+
+            if (isWindowClosed(source)) {
+                return;
+            }
+
+            try {
+                canary();
+            } catch (err) {
+                return;
+            }
+
+            sendMessage.apply(this, arguments);
+        }
+    }, { domain: '*' });
+};
+

src/bridge/child.js

@@ -0,0 +1,121 @@
+
+import { SyncPromise as Promise } from 'sync-browser-mocks/src/promise';
+import { CONSTANTS } from '../conf';
+import { isSameDomain, getOpener, getFrames, util, getFrameByName } from '../lib';
+import { receiveMessage } from '../drivers';
+
+import { needsBridge, registerRemoteWindow, rejectRemoteSendMessage, registerRemoteSendMessage, getBridgeName } from './common';
+
+function getRemoteBridgeForWindow(win) {
+    return Promise.try(() => {
+        for (let frame of getFrames(win)) {
+            try {
+                if (frame && frame !== window && isSameDomain(frame) && frame[CONSTANTS.WINDOW_PROPS.POSTROBOT]) {
+                    return frame;
+                }
+
+            } catch (err) {
+                continue;
+            }
+        }
+
+        try {
+            let frame = getFrameByName(win, getBridgeName(util.getDomain()));
+
+            if (!frame) {
+                return;
+            }
+
+            if (isSameDomain(frame) && frame[CONSTANTS.WINDOW_PROPS.POSTROBOT]) {
+                return frame;
+            }
+
+            return new Promise(resolve => {
+
+                let interval;
+                let timeout;
+
+                interval = setInterval(() => {
+                    if (isSameDomain(frame) && frame[CONSTANTS.WINDOW_PROPS.POSTROBOT]) {
+                        clearInterval(interval);
+                        clearTimeout(timeout);
+                        return resolve(frame);
+                    }
+
+                    setTimeout(() => {
+                        clearInterval(interval);
+                        return resolve();
+                    }, 2000);
+                }, 100);
+            });
+
+        } catch (err) {
+            return;
+        }
+    });
+}
+
+export function openTunnelToOpener() {
+    return Promise.try(() => {
+
+        let opener = getOpener(window);
+
+        if (!opener) {
+            return;
+        }
+
+        if (!needsBridge({ win: opener })) {
+            return;
+        }
+
+        registerRemoteWindow(opener);
+
+        return getRemoteBridgeForWindow(opener).then(bridge => {
+
+            if (!bridge) {
+                return rejectRemoteSendMessage(opener, new Error(`Can not register with opener: no bridge found in opener`));
+            }
+
+            if (!window.name) {
+                return rejectRemoteSendMessage(opener, new Error(`Can not register with opener: window does not have a name`));
+            }
+
+            return bridge[CONSTANTS.WINDOW_PROPS.POSTROBOT].openTunnelToParent({
+
+                name: window.name,
+
+                source: window,
+
+                canary() {
+                    // pass
+                },
+
+                sendMessage(message) {
+
+                    if (!window || window.closed) {
+                        return;
+                    }
+
+                    receiveMessage({
+                        data:   message,
+                        origin: this.origin,
+                        source: this.source
+                    });
+                }
+
+            }).then(({ source, origin, data }) => {
+
+                if (source !== opener) {
+                    throw new Error(`Source does not match opener`);
+                }
+
+                registerRemoteSendMessage(source, origin, data.sendMessage);
+
+            }).catch(err => {
+
+                rejectRemoteSendMessage(opener, err);
+                throw err;
+            });
+        });
+    });
+}

src/bridge/common.js

@@ -0,0 +1,148 @@
+
+import { CONFIG, CONSTANTS } from '../conf';
+import { util, promise, isSameDomain, isOpener, isSameTopWindow, getUserAgent } from '../lib';
+import { global } from '../global';
+import { receiveMessage } from '../drivers';
+
+export function needsBridgeForBrowser() {
+
+    if (getUserAgent(window).match(/MSIE|trident|edge/i)) {
+        return true;
+    }
+
+    if (!CONFIG.ALLOW_POSTMESSAGE_POPUP) {
+        return true;
+    }
+
+    return false;
+}
+
+export function needsBridgeForWin(win) {
+
+    if (win && isSameTopWindow(window, win)) {
+        return false;
+    }
+
+    if (win && isSameDomain(win)) {
+        return false;
+    }
+
+    return true;
+}
+
+export function needsBridgeForDomain(domain) {
+
+    if (domain && util.getDomain() === util.getDomainFromUrl(domain)) {
+        return false;
+    }
+
+    return true;
+}
+
+export function needsBridge({ win, domain }) {
+    return needsBridgeForBrowser() && needsBridgeForWin(win) && needsBridgeForDomain(domain);
+}
+
+export function getBridgeName(domain) {
+
+    domain = domain || util.getDomainFromUrl(domain);
+
+    let sanitizedDomain = domain.replace(/[^a-zA-Z0-9]+/g, '_');
+
+    let id = `${CONSTANTS.BRIDGE_NAME_PREFIX}_${sanitizedDomain}`;
+
+    return id;
+}
+
+export function isBridge() {
+    return window.name && window.name === getBridgeName(util.getDomain());
+}
+
+export let documentBodyReady = new promise.Promise(resolve => {
+
+    if (window.document && window.document.body) {
+        return resolve(window.document.body);
+    }
+
+    let interval = setInterval(() => {
+        if (window.document && window.document.body) {
+            clearInterval(interval);
+            return resolve(window.document.body);
+        }
+    }, 10);
+});
+
+global.remoteWindows = global.remoteWindows || [];
+
+export function registerRemoteWindow(win, timeout = CONFIG.BRIDGE_TIMEOUT) {
+    let sendMessagePromise = new promise.Promise();
+    global.clean.push(global.remoteWindows, { win, sendMessagePromise });
+}
+
+export function findRemoteWindow(win) {
+    for (let i = 0; i < global.remoteWindows.length; i++) {
+        if (global.remoteWindows[i].win === win) {
+            return global.remoteWindows[i];
+        }
+    }
+}
+
+export function registerRemoteSendMessage(win, domain, sendMessage) {
+
+    let remoteWindow = findRemoteWindow(win);
+
+    if (!remoteWindow) {
+        throw new Error(`Window not found to register sendMessage to`);
+    }
+
+    let sendMessageWrapper = (remoteWin, message, remoteDomain) => {
+
+        if (remoteWin !== win) {
+            throw new Error(`Remote window does not match window`);
+        }
+
+        if (remoteDomain !== `*` && remoteDomain !== domain) {
+            throw new Error(`Remote domain ${remoteDomain} does not match domain ${domain}`);
+        }
+
+        sendMessage(message);
+    };
+
+    remoteWindow.sendMessagePromise.resolve(sendMessageWrapper);
+    remoteWindow.sendMessagePromise = promise.Promise.resolve(sendMessageWrapper);
+}
+
+export function rejectRemoteSendMessage(win, err) {
+
+    let remoteWindow = findRemoteWindow(win);
+
+    if (!remoteWindow) {
+        throw new Error(`Window not found on which to reject sendMessage`);
+    }
+
+    return remoteWindow.sendMessagePromise.asyncReject(err);
+}
+
+export function sendBridgeMessage(win, message, domain) {
+
+    let messagingChild  = isOpener(window, win);
+    let messagingParent = isOpener(win, window);
+
+    if (!messagingChild && !messagingParent) {
+        throw new Error(`Can only send messages to and from parent and popup windows`);
+    }
+
+    let remoteWindow = findRemoteWindow(win);
+
+    if (!remoteWindow) {
+        throw new Error(`Window not found to send message to`);
+    }
+
+    return remoteWindow.sendMessagePromise.then(sendMessage => {
+        return sendMessage(win, message, domain);
+    });
+}
+
+global.receiveMessage = function(event) {
+    return receiveMessage(event);
+};