js/xpconnect/tests/unit/test_envChain_frameScript.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 "use strict";
   6
   7 // Verify the environment chain for frame scripts described in
   8 // js/src/vm/EnvironmentObject.h.
   9
  10 const { XPCShellContentUtils } = ChromeUtils.importESModule(
  11   "resource://testing-common/XPCShellContentUtils.sys.mjs"
  12 );
  13
  14 XPCShellContentUtils.init(this);
  15
  16 add_task(async function unique_scope() {
  17   const page = await XPCShellContentUtils.loadContentPage("about:blank", {
  18     remote: true,
  19   });
  20
  21   const envsPromise = new Promise(resolve => {
  22     Services.mm.addMessageListener("unique-envs-result", msg => {
  23       resolve(msg.data);
  24     });
  25   });
  26   const sharePromise = new Promise(resolve => {
  27     Services.mm.addMessageListener("unique-share-result", msg => {
  28       resolve(msg.data);
  29     });
  30   });
  31
  32   const runInUniqueScope = true;
  33   const runInGlobalScope = !runInUniqueScope;
  34
  35   Services.mm.loadFrameScript(`data:,
  36 var unique_qualified = 10;
  37 unique_unqualified = 20;
  38 let unique_lexical = 30;
  39 this.unique_prop = 40;
  40
  41 const funcs = Cu.getJSTestingFunctions();
  42 const envs = [];
  43 let env = funcs.getInnerMostEnvironmentObject();
  44 while (env) {
  45   envs.push({
  46     type: funcs.getEnvironmentObjectType(env) || "*SystemGlobal*",
  47     qualified: !!Object.getOwnPropertyDescriptor(env, "unique_qualified"),
  48     unqualified: !!Object.getOwnPropertyDescriptor(env, "unique_unqualified"),
  49     lexical: !!Object.getOwnPropertyDescriptor(env, "unique_lexical"),
  50     prop: !!Object.getOwnPropertyDescriptor(env, "unique_prop"),
  51   });
  52
  53   env = funcs.getEnclosingEnvironmentObject(env);
  54 }
  55
  56 sendSyncMessage("unique-envs-result", envs);
  57 `, false, runInGlobalScope);
  58
  59   Services.mm.loadFrameScript(`data:,
  60 sendSyncMessage("unique-share-result", {
  61   unique_qualified: typeof unique_qualified,
  62   unique_unqualified: typeof unique_unqualified,
  63   unique_lexical: typeof unique_lexical,
  64   unique_prop: this.unique_prop,
  65 });
  66 `, false, runInGlobalScope);
  67
  68   const envs = await envsPromise;
  69   const share = await sharePromise;
  70
  71   Assert.equal(envs.length, 5);
  72
  73   let i = 0, env;
  74
  75   env = envs[i]; i++;
  76   Assert.equal(env.type, "NonSyntacticLexicalEnvironmentObject");
  77   Assert.equal(env.qualified, false);
  78   Assert.equal(env.unqualified, false);
  79   Assert.equal(env.lexical, true, "lexical must live in the NSLEO");
  80   Assert.equal(env.prop, false);
  81
  82   env = envs[i]; i++;
  83   Assert.equal(env.type, "WithEnvironmentObject");
  84   Assert.equal(env.qualified, false);
  85   Assert.equal(env.unqualified, false);
  86   Assert.equal(env.lexical, false);
  87   Assert.equal(env.prop, true, "this property must live in the with env");
  88
  89   env = envs[i]; i++;
  90   Assert.equal(env.type, "NonSyntacticVariablesObject");
  91   Assert.equal(env.qualified, true, "qualified var must live in the NSVO");
  92   Assert.equal(env.unqualified, true, "unqualified var must live in the NSVO");
  93   Assert.equal(env.lexical, false);
  94   Assert.equal(env.prop, false);
  95
  96   env = envs[i]; i++;
  97   Assert.equal(env.type, "GlobalLexicalEnvironmentObject");
  98   Assert.equal(env.qualified, false);
  99   Assert.equal(env.unqualified, false);
 100   Assert.equal(env.lexical, false);
 101   Assert.equal(env.prop, false);
 102
 103   env = envs[i]; i++;
 104   Assert.equal(env.type, "*SystemGlobal*");
 105   Assert.equal(env.qualified, false);
 106   Assert.equal(env.unqualified, false);
 107   Assert.equal(env.lexical, false);
 108   Assert.equal(env.prop, false);
 109
 110   Assert.equal(share.unique_qualified, "undefined", "qualified var must not be shared");
 111   Assert.equal(share.unique_unqualified, "undefined", "unqualified name must not be shared");
 112   Assert.equal(share.unique_lexical, "undefined", "lexical must not be shared");
 113   Assert.equal(share.unique_prop, 40, "this property must be shared");
 114
 115   await page.close();
 116 });
 117
 118 add_task(async function non_unique_scope() {
 119   const page = await XPCShellContentUtils.loadContentPage("about:blank", {
 120     remote: true,
 121   });
 122
 123   const envsPromise = new Promise(resolve => {
 124     Services.mm.addMessageListener("non-unique-envs-result", msg => {
 125       resolve(msg.data);
 126     });
 127   });
 128   const sharePromise = new Promise(resolve => {
 129     Services.mm.addMessageListener("non-unique-share-result", msg => {
 130       resolve(msg.data);
 131     });
 132   });
 133
 134   const runInUniqueScope = false;
 135   const runInGlobalScope = !runInUniqueScope;
 136
 137   Services.mm.loadFrameScript(`data:,
 138 var non_unique_qualified = 10;
 139 non_unique_unqualified = 20;
 140 let non_unique_lexical = 30;
 141 this.non_unique_prop = 40;
 142
 143 const funcs = Cu.getJSTestingFunctions();
 144 const envs = [];
 145 let env = funcs.getInnerMostEnvironmentObject();
 146 while (env) {
 147   envs.push({
 148     type: funcs.getEnvironmentObjectType(env) || "*SystemGlobal*",
 149     qualified: !!Object.getOwnPropertyDescriptor(env, "non_unique_qualified"),
 150     unqualified: !!Object.getOwnPropertyDescriptor(env, "non_unique_unqualified"),
 151     lexical: !!Object.getOwnPropertyDescriptor(env, "non_unique_lexical"),
 152     prop: !!Object.getOwnPropertyDescriptor(env, "non_unique_prop"),
 153   });
 154
 155   env = funcs.getEnclosingEnvironmentObject(env);
 156 }
 157
 158 sendSyncMessage("non-unique-envs-result", envs);
 159 `, false, runInGlobalScope);
 160
 161   Services.mm.loadFrameScript(`data:,
 162 sendSyncMessage("non-unique-share-result", {
 163   non_unique_qualified,
 164   non_unique_unqualified,
 165   non_unique_lexical,
 166   non_unique_prop,
 167 });
 168 `, false, runInGlobalScope);
 169
 170   const envs = await envsPromise;
 171   const share = await sharePromise;
 172
 173   Assert.equal(envs.length, 4);
 174
 175   let i = 0, env;
 176
 177   env = envs[i]; i++;
 178   Assert.equal(env.type, "NonSyntacticLexicalEnvironmentObject");
 179   Assert.equal(env.qualified, false);
 180   Assert.equal(env.unqualified, false);
 181   Assert.equal(env.lexical, true, "lexical must live in the NSLEO");
 182   Assert.equal(env.prop, false);
 183
 184   env = envs[i]; i++;
 185   Assert.equal(env.type, "WithEnvironmentObject");
 186   Assert.equal(env.qualified, true, "qualified var must live in the with env");
 187   Assert.equal(env.unqualified, false);
 188   Assert.equal(env.lexical, false);
 189   Assert.equal(env.prop, true, "this property must live in the with env");
 190
 191   env = envs[i]; i++;
 192   Assert.equal(env.type, "GlobalLexicalEnvironmentObject");
 193   Assert.equal(env.qualified, false);
 194   Assert.equal(env.unqualified, false);
 195   Assert.equal(env.lexical, false);
 196   Assert.equal(env.prop, false);
 197
 198   env = envs[i]; i++;
 199   Assert.equal(env.type, "*SystemGlobal*");
 200   Assert.equal(env.qualified, false);
 201   Assert.equal(env.unqualified, true, "unqualified name must live in the system global");
 202   Assert.equal(env.lexical, false);
 203   Assert.equal(env.prop, false);
 204
 205   Assert.equal(share.non_unique_qualified, 10, "qualified var must be shared");
 206   Assert.equal(share.non_unique_unqualified, 20, "unqualified name must be shared");
 207   Assert.equal(share.non_unique_lexical, 30, "lexical must be shared");
 208   Assert.equal(share.non_unique_prop, 40, "this property must be shared");
 209
 210   await page.close();
 211 });