feat(venmo): allow trusted domains

src/child/props.js

@@ -82,11 +82,12 @@ export function normalizeChildProps<P, X>(
   for (const key of Object.keys(props)) {
     const prop = propsDef[key];
 
-    if (
-      prop &&
-      prop.sameDomain &&
-      (origin !== getDomain(window) || !isSameDomain(parentComponentWindow))
-    ) {
+    const trustedChild: boolean =
+      prop && prop.trustedDomains && prop.trustedDomains.length > 0
+        ? prop.trustedDomains.indexOf(getDomain(window)) !== -1
+        : origin === getDomain(window) || isSameDomain(parentComponentWindow);
+
+    if (prop && prop.sameDomain && !trustedChild) {
       continue;
     }
 

src/component/props.js

@@ -191,6 +191,7 @@ export type PropDefinitionType<T, P, S: $Values<typeof PROP_TYPE>, X> = {|
   validate?: ({| value: T, props: PropsType<P> |}) => void,
   sameDomain?: boolean,
   serialization?: $Values<typeof PROP_SERIALIZATION>,
+  trustedDomains?: $ReadOnlyArray<string>,
 |};
 
 export type BOOLEAN_DEFINITION_TYPE = typeof PROP_TYPE.BOOLEAN;

src/parent/parent.js

@@ -378,11 +378,12 @@ export function parentComponent<P, X, C>({
         continue;
       }
 
-      if (
-        prop &&
-        prop.sameDomain &&
-        !matchDomain(initialChildDomain, getDomain(window))
-      ) {
+      const trustedChild: boolean =
+        prop && prop.trustedDomains && prop.trustedDomains.length > 0
+          ? prop.trustedDomains.indexOf(initialChildDomain) !== -1
+          : matchDomain(initialChildDomain, getDomain(window));
+
+      if (prop && prop.sameDomain && !trustedChild) {
         continue;
       }
 

test/tests/props.js

@@ -813,6 +813,73 @@ describe("zoid props cases", () => {
     });
   });
 
+  it("should pass a trustedDomain prop and have it populate on the child", () => {
+    return wrapPromise(({ expect }) => {
+      window.__component__ = () => {
+        return zoid.create({
+          tag: "test-trusteddomain-prop-passed",
+          url: "mock://www.child.com/base/test/windows/child/index.htm",
+          domain: ["mock://www.child.com"],
+          props: {
+            foo: {
+              type: "string",
+              trustedDomains: ["mock://www.child.com"],
+            },
+          },
+        });
+      };
+
+      const component = window.__component__();
+      const instance = component({
+        foo: "bar",
+        passProp: expect("passProp", (val) => {
+          if (!val) {
+            throw new Error(`Expected val to be passed`);
+          }
+        }),
+        run: () => `
+                    window.xprops.passProp(window.xprops.foo);
+                `,
+      });
+
+      return instance.render(getBody());
+    });
+  });
+
+  it("should pass a trustedDomain and sameDomain=true prop and have it populate on the child", () => {
+    return wrapPromise(({ expect }) => {
+      window.__component__ = () => {
+        return zoid.create({
+          tag: "test-samedomain-trusteddomain-prop-passed",
+          url: "mock://www.child.com/base/test/windows/child/index.htm",
+          domain: ["mock://www.child.com"],
+          props: {
+            foo: {
+              type: "string",
+              sameDomain: true,
+              trustedDomains: ["mock://www.child.com"],
+            },
+          },
+        });
+      };
+
+      const component = window.__component__();
+      const instance = component({
+        foo: "bar",
+        passProp: expect("passProp", (val) => {
+          if (!val) {
+            throw new Error(`Expected val to be passed`);
+          }
+        }),
+        run: () => `
+                    window.xprops.passProp(window.xprops.foo);
+                `,
+      });
+
+      return instance.render(getBody());
+    });
+  });
+
   it("should alias a prop and have it copy correctly", () => {
     return wrapPromise(({ expect }) => {
       window.__component__ = () => {