tor-browser

capture-stack.js (10733B)

---

// |jit-test| --setpref=experimental.error_capture_stack_trace;
load(libdir + "asserts.js");

if ('captureStackTrace' in Error) {
   assertEq(Error.captureStackTrace.length, 2);

   let x = Error.captureStackTrace({});
   assertEq(x, undefined);

   assertThrowsInstanceOf(() => Error.captureStackTrace(), TypeError);
   assertThrowsInstanceOf(() => Error.captureStackTrace(2), TypeError);

   Error.captureStackTrace({}, 2);
   Error.captureStackTrace({}, null);
   Error.captureStackTrace({}, {});

   function caller(f) {
       return f();
   }

   function fill() {
       let x = {}
       Error.captureStackTrace(x, caller);
       return x;
   }

   function test_elision() {
       let x = caller(fill);
       let { stack } = x;
       assertEq(stack.includes("caller"), false);
       assertEq(stack.includes("fill"), false);


       ({ stack } = caller(() => caller(fill)))
       print(stack);
       assertEq(stack.includes("caller"), true); // Only elide the first caller!
       assertEq(stack.includes("fill"), false);
   }

   test_elision();

   function nestedLambda(f) {
       (() => {
           (() => {
               (() => {
                   (() => {
                       f();
                   })();
               })();
           })();
       })();
   }


   // If we never see a matching frame when requesting a truncated
   // stack we should return the empty string
   function test_no_match() {
       let obj = {};
       // test_elision chosen arbitrarily as a function object which
       // doesn't exist in the call stack here.
       let capture = () => Error.captureStackTrace(obj, test_elision);
       nestedLambda(capture);
       assertEq(obj.stack, "");
   }
   test_no_match()

   function count_frames(str) {
       return str.split("\n").length
   }

   function test_nofilter() {
       let obj = {};
       let capture = () => Error.captureStackTrace(obj);
       nestedLambda(capture);
       assertEq(count_frames(obj.stack), 9);
   }
   test_nofilter();

   function test_in_eval() {
       let obj = eval(`
       let obj = {};
       let capture = () => Error.captureStackTrace(obj);
       nestedLambda(capture);
       obj
       `)

       // Same as above, with an eval frame added!
       assertEq(count_frames(obj.stack), 10);
   }
   test_in_eval();

   //
   // [[ErrorData]]
   //
   const stackGetter = Object.getOwnPropertyDescriptor(Error.prototype, 'stack').get;
   const getStack = function (obj) {
       return stackGetter.call(obj);
   };

   function test_uncensored() {
       let err = undefined;
       function create_err() {
           err = new Error;
           Error.captureStackTrace(err, test_uncensored);
       }

       nestedLambda(create_err);

       // Calling Error.captureStackTrace doesn't mess with the internal
       // [[ErrorData]] slot
       assertEq(count_frames(err.stack), 2);
       assertEq(count_frames(getStack(err)), 9)
   }
   test_uncensored()

   // In general, the stacks a non-caller version of Error.captureStackStrace
   // should match what Error gives you
   function compare_stacks() {
       function censor_column(str) {
           return str.replace(/:(\d+):\d+\n/g, ":$1:censored\n")
       }

       let obj = {};
       let err = (Error.captureStackTrace(obj), new Error)
       assertEq(censor_column(err.stack), censor_column(obj.stack));
   }
   compare_stacks();
   nestedLambda(compare_stacks)

   // New global

   function test_in_global(global) {
       global.evaluate(caller.toString());
       global.evaluate(fill.toString());
       global.evaluate(test_elision.toString());
       global.evaluate("test_elision()");

       global.evaluate(nestedLambda.toString())
       global.evaluate(test_no_match.toString());
       global.evaluate("test_no_match()");


       global.evaluate(compare_stacks.toString());
       global.evaluate(`
           compare_stacks();
           nestedLambda(compare_stacks)
       `)
   }

   let global = newGlobal();
   test_in_global(global);

   let global2 = newGlobal({ principal: 0 });
   test_in_global(global2)

   let global3 = newGlobal({ principal: 0xfffff });
   test_in_global(global3)

   // What if the caller is a proxy?
   const caller_proxy = new Proxy(caller, {
       apply: function (target, thisArg, arguments) {
           return target(...arguments);
       }
   });

   function fill_proxy() {
       let x = {}
       Error.captureStackTrace(x, caller_proxy);
       return x;
   }

   // Proxies don't count for elision.
   function test_proxy_elision() {
       let x = caller_proxy(fill_proxy);
       let { stack } = x;
       assertEq(stack.includes("caller"), true);
       assertEq(stack.includes("fill_proxy"), true);
   }
   test_proxy_elision();

   const trivial_proxy = new Proxy(caller, {});
   function fill_trivial() {
       let x = {}
       Error.captureStackTrace(x, trivial_proxy);
       return x;
   }

   // Elision doesn't work even on forwarding proxy
   function test_trivial_elision() {
       let x = caller(fill_trivial);
       let { stack } = x;
       assertEq(stack.includes("caller"), true);
       assertEq(stack.includes("fill"), true);
   }
   test_trivial_elision();

   // Elision happens through bind
   function test_bind_elision() {
       let b = caller.bind(undefined, fill);
       let { stack } = b();
       assertEq(stack.includes("caller"), false);
       assertEq(stack.includes("fill"), false);
   }
   test_bind_elision();

   // Cross Realm testing

   let nr = newGlobal({ newCompartment: true })
   nr.eval(`globalThis.x = {}`);
   Error.captureStackTrace(nr.x);

   // Test strict definition
   function test_strict_definition() {
       "use strict";
       assertThrowsInstanceOf(() => Error.captureStackTrace(Object.freeze({ stack: null })), TypeError);
   }
   test_strict_definition();

   function test_property_descriptor() {
       let o = {};
       Error.captureStackTrace(o);
       let desc = Object.getOwnPropertyDescriptor(o, "stack");
       assertEq(desc.configurable, true)
       assertEq(desc.writable, true)
       assertEq(desc.enumerable, false)
   }
   test_property_descriptor();

   function test_delete() {
       let o = {};
       Error.captureStackTrace(o);
       delete o.stack
       assertEq("stack" in o, false)
   }
   test_delete();

   // Principal testing: This is basic/shell-principals.js extended to support
   // and compare Error.captureStackTrace.
   //
   // Reminder:
   // >  In the shell, a principal is simply a 32-bit mask: P subsumes Q if the
   // >  set bits in P are a superset of those in Q. Thus, the principal 0 is
   // >  subsumed by everything, and the principal ~0 subsumes everything.

   // Given a string of letters |expected|, say "abc", assert that the stack
   // contains calls to a series of functions named by the next letter from
   // the string, say a, b, and then c. Younger frames appear earlier in
   // |expected| than older frames.
   let count = 0;
   function check(expected, stack) {
       print("check(" + JSON.stringify(expected) + ") against:\n" + stack);
       count++;

       // Extract only the function names from the stack trace. Omit the frames
       // for the top-level evaluation, if it is present.
       var split = stack.split(/(.)?@.*\n/).slice(0, -1);
       if (split[split.length - 1] === undefined)
           split = split.slice(0, -2);

       print(JSON.stringify(split));
       // Check the function names against the expected sequence.
       assertEq(split.length, expected.length * 2);
       for (var i = 0; i < expected.length; i++)
           assertEq(split[i * 2 + 1], expected[i]);
   }

   var low = newGlobal({ principal: 0 });
   var mid = newGlobal({ principal: 0xffff });
   var high = newGlobal({ principal: 0xfffff });

   eval('function a() { let o = {}; Error.captureStackTrace(o); check("a",    o.stack); b(); }');
   low.eval('function b() { let o = {}; Error.captureStackTrace(o); check("b",    o.stack); c(); }');
   mid.eval('function c() { let o = {}; Error.captureStackTrace(o); check("cba",  o.stack); d(); }');
   high.eval('function d() { let o = {}; Error.captureStackTrace(o); check("dcba", o.stack); e(); }');

   // Globals created with no explicit principals get 0xffff.
   eval('function e() { let o = {}; Error.captureStackTrace(o); check("ecba",     o.stack); f(); }');

   low.eval('function f() { let o = {}; Error.captureStackTrace(o); check("fb",       o.stack); g(); }');
   mid.eval('function g() { let o = {}; Error.captureStackTrace(o); check("gfecba",   o.stack); h(); }');
   high.eval('function h() { let o = {}; Error.captureStackTrace(o); check("hgfedcba", o.stack);      }');

   // Make everyone's functions visible to each other, as needed.
   b = low.b;
   low.c = mid.c;
   mid.d = high.d;
   high.e = e;
   f = low.f;
   low.g = mid.g;
   mid.h = high.h;

   low.check = mid.check = high.check = check;

   // Kick the whole process off.
   a();

   assertEq(count, 8);

   // Ensure filtering is based on caller realm not on target object.
   low.eval("low_target = {}");
   mid.eval("mid_target = {}");
   high.eval("high_target = {}");

   high.low_target = mid.low_target = low.low_target;
   high.mid_target = low.mid_target = mid.mid_target;
   mid.high_target = low.high_target = high.high_target;

   high.low_cst = mid.low_cst = low.low_cst = low.Error.captureStackTrace;
   high.mid_cst = low.mid_cst = mid.mid_cst = mid.Error.captureStackTrace;
   mid.high_cst = low.high_cst = high.high_cst = high.Error.captureStackTrace;

   for (let g of [low, mid, high]) {
       assertEq("low_target" in g, true);
       assertEq("mid_target" in g, true);
       assertEq("high_target" in g, true);

       assertEq("low_cst" in g, true);
       assertEq("mid_cst" in g, true);
       assertEq("high_cst" in g, true);

       // install caller function z -- single letter name for
       // check compat.
       g.eval("function z(f) { f() }")
   }

   low.eval("function q() { Error.captureStackTrace(low_target); }")


   high.q = low.q;

   // Caller function z is from high, but using low Error.captureStackTrace, so
   // z should be elided.
   high.eval("z(q)");
   check("q", low.low_target.stack);

   low.eval("function r() { high_cst(low_target) }")
   high.r = low.r;

   // Can see everything here using high cst and low target.
   high.eval("function t() { z(r) }");
   high.t();
   check("rzt", low.low_target.stack);


}