Allow serializing using proxy window

Author: bluepnume

src/lib/hello.js

@@ -10,6 +10,7 @@ import { global } from '../global';
 
 global.instanceID = global.instanceID || uniqueID();
 global.helloPromises = global.helloPromises || new WeakMap();
+global.onHello = global.onHello || [];
 
 function getHelloPromise(win : CrossDomainWindowType) : ZalgoPromise<{ win : CrossDomainWindowType, domain : string }> {
     return global.helloPromises.getOrSet(win, () => new ZalgoPromise());
@@ -18,14 +19,12 @@ function getHelloPromise(win : CrossDomainWindowType) : ZalgoPromise<{ win : Cro
 const listenForHello = once(() => {
     global.on(MESSAGE_NAME.HELLO, { domain: WILDCARD }, ({ source, origin }) => {
         getHelloPromise(source).resolve({ win: source, domain: origin });
-        return {
-            instanceID: global.instanceID
-        };
+        return { instanceID: global.instanceID };
     });
 });
 
 export function sayHello(win : CrossDomainWindowType) : ZalgoPromise<{ win : CrossDomainWindowType, domain : string, instanceID : string }> {
-    return global.send(win, MESSAGE_NAME.HELLO, {}, { domain: WILDCARD, timeout: -1 })
+    return global.send(win, MESSAGE_NAME.HELLO, { instanceID: global.instanceID }, { domain: WILDCARD, timeout: -1 })
         .then(({ origin, data: { instanceID } }) => {
             getHelloPromise(win).resolve({ win, domain: origin });
             return { win, domain: origin, instanceID };

src/lib/windows.js

@@ -1,31 +1,14 @@
 /* @flow */
 
-import { type CrossDomainWindowType, isWindowClosed } from 'cross-domain-utils/src';
+import { WeakMap } from 'cross-domain-safe-weakmap/src';
+import { type CrossDomainWindowType } from 'cross-domain-utils/src';
 
-global.knownWindows = global.knownWindows || [];
-global.onKnownWindow = global.onKnownWindow || [];
+global.knownWindows = global.knownWindows || new WeakMap();
 
 export function markWindowKnown(win : CrossDomainWindowType) {
-    global.knownWindows = global.knownWindows.filter(knownWindow => !isWindowClosed(knownWindow));
-    if (global.knownWindows.indexOf(win) === -1) {
-        global.knownWindows.push(win);
-        for (let handler of global.onKnownWindow) {
-            handler(win);
-        }
-    }
+    global.knownWindows.set(win, true);
 }
 
 export function isWindowKnown(win : CrossDomainWindowType) : boolean {
-    return global.knownWindows.indexOf(win) !== -1;
-}
-
-export function getKnownWindows() : $ReadOnlyArray<CrossDomainWindowType> {
-    return global.knownWindows;
-}
-
-export function onKnownWindow(handler : (CrossDomainWindowType) => void) {
-    global.onKnownWindow.push(handler);
-    for (let win of global.knownWindows) {
-        handler(win);
-    }
+    return global.knownWindows.get(win, false);
 }

src/serialize/function.js

@@ -9,30 +9,46 @@ import { serializeType, type CustomSerializedType } from 'universal-serialize/sr
 import { MESSAGE_NAME, WILDCARD, SERIALIZATION_TYPE } from '../conf';
 import { global } from '../global';
 
+import { ProxyWindow } from './window';
+
 global.methods = global.methods || new WeakMap();
+global.proxyWindowMethods = global.proxyWindowMethods || {};
 
 const listenForFunctionCalls = once(() => {
     global.on(MESSAGE_NAME.METHOD, { origin: WILDCARD }, ({ source, origin, data } : { source : CrossDomainWindowType, origin : string, data : Object }) => {
-        let methods = global.methods.get(source);
+        let { id, name } = data;
+        
+        return ZalgoPromise.try(() => {
+            let methods = global.methods.get(source) || {};
+            let meth = methods[data.id] || global.proxyWindowMethods[id];
 
-        if (!methods) {
-            throw new Error(`Could not find any methods this window has privileges to call`);
-        }
+            if (!meth) {
+                throw new Error(`Could not find method with id: ${ data.id }`);
+            }
 
-        let meth = methods[data.id];
+            let { proxy, domain, val } = meth;
 
-        if (!meth) {
-            throw new Error(`Could not find method with id: ${ data.id }`);
-        }
+            if (!matchDomain(domain, origin)) {
+                throw new Error(`Method domain ${ meth.domain } does not match origin ${ origin }`);
+            }
+            
+            if (proxy) {
+                return proxy.matchWindow(source).then(match => {
+                    if (!match) {
+                        throw new Error(`Proxy window does not match source`);
+                    }
 
-        if (!matchDomain(meth.domain, origin)) {
-            throw new Error(`Method domain ${ meth.domain } does not match origin ${ origin }`);
-        }
+                    delete global.proxyWindowMethods[id];
+                    return val;
+                });
+            }
+
+            return val;
+
+        }).then(method => {
+            return method.apply({ source, origin, data }, data.args);
 
-        return ZalgoPromise.try(() => {
-            return meth.val.apply({ source, origin, data }, data.args);
         }).then(result => {
-            const { id, name } = data;
             return { result, id, name };
         });
     });
@@ -43,20 +59,19 @@ export type SerializedFunction = CustomSerializedType<typeof SERIALIZATION_TYPE.
     name : string
 }>;
 
-export function serializeFunction<T>(destination : CrossDomainWindowType, domain : string | Array<string>, val : () => ZalgoPromise<T> | T, key : string) : SerializedFunction {
+export function serializeFunction<T>(destination : CrossDomainWindowType | ProxyWindow, domain : string | Array<string>, val : () => ZalgoPromise<T> | T, key : string) : SerializedFunction {
+    listenForFunctionCalls();
+    
     let id = uniqueID();
+    destination = ProxyWindow.unwrap(destination);
 
-    let methods = global.methods.get(destination);
-
-    if (!methods) {
-        methods = {};
-        global.methods.set(destination, methods);
+    if (ProxyWindow.isProxyWindow(destination)) {
+        global.proxyWindowMethods[id] = { proxy: destination, domain, val };
+    } else {
+        let methods = global.methods.getOrSet(destination, () => ({}));
+        methods[id] = { domain, val };
     }
 
-    methods[id] = { domain, val };
-
-    listenForFunctionCalls();
-
     return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION, { id, name: val.name || key });
 }
 

src/serialize/promise.js

@@ -7,12 +7,13 @@ import { serializeType, type CustomSerializedType, type Thenable } from 'univers
 import { SERIALIZATION_TYPE } from '../conf';
 
 import { serializeFunction, type SerializedFunction } from './function';
+import { ProxyWindow } from './window';
 
 export type SerializedPromise = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_ZALGO_PROMISE, {
     then : SerializedFunction
 }>;
 
-export function serializePromise(destination : CrossDomainWindowType, domain : string | Array<string>, val : Thenable, key : string) : SerializedPromise {
+export function serializePromise(destination : CrossDomainWindowType | ProxyWindow, domain : string | Array<string>, val : Thenable, key : string) : SerializedPromise {
     return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_ZALGO_PROMISE, {
         then: serializeFunction(destination, domain, (resolve, reject) => val.then(resolve, reject), key)
     });

src/serialize/serialize.js

@@ -9,14 +9,12 @@ import { serializeFunction, deserializeFunction, type SerializedFunction } from
 import { serializePromise, deserializePromise, type SerializedPromise } from './promise';
 import { serializeWindow, deserializeWindow, type SerializedWindow, ProxyWindow } from './window';
 
-export function serializeMessage<T : mixed>(destination : CrossDomainWindowType, domain : string | Array<string>, obj : T) : string {
+export function serializeMessage<T : mixed>(destination : CrossDomainWindowType | ProxyWindow, domain : string | Array<string>, obj : T) : string {
     return serialize(obj, {
         [ TYPE.PROMISE ]:  (val : Thenable, key : string) : SerializedPromise => serializePromise(destination, domain, val, key),
         [ TYPE.FUNCTION ]: (val : Function, key : string) : SerializedFunction => serializeFunction(destination, domain, val, key),
         [ TYPE.OBJECT ]:   (val : CrossDomainWindowType) : Object | SerializedWindow => {
-            return (isWindow(val) || ProxyWindow.isProxyWindow(val))
-                ? serializeWindow(destination, domain, val)
-                : val;
+            return (isWindow(val) || ProxyWindow.isProxyWindow(val)) ? serializeWindow(destination, domain, val) : val;
         }
     });
 }