The Tor Browser: toolkit/devtools/server/tests/unit/test_trace_actor-06.js@129ffea94266 (annotated)

toolkit/devtools/server/tests/unit/test_trace_actor-06.js@129ffea94266 (annotated)

toolkit/devtools/server/tests/unit/test_trace_actor-06.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */
 /**
  * Tests that values are correctly serialized and sent in enteredFrame
  * and exitedFrame packets.
  */
 var gDebuggee;
 var gClient;
 var gTraceClient;
 function run_test()
 {
   initTestTracerServer();
   gDebuggee = addTestGlobal("test-tracer-actor");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect(function() {
     attachTestTab(gClient, "test-tracer-actor", function(aResponse, aTabClient) {
       gClient.attachTracer(aResponse.traceActor, function(aResponse, aTraceClient) {
         gTraceClient = aTraceClient;
         test_enter_exit_frame();
       });
     });
   });
   do_test_pending();
 }
 function test_enter_exit_frame()
 {
   const traceStopped = promise.defer();
   gClient.addListener("traces", (aEvent, { traces }) => {
     for (let t of traces) {
       check_trace(t);
       if (t.sequence === 27) {
         traceStopped.resolve();
       }
     }
   });
   start_trace()
     .then(eval_code)
     .then(() => traceStopped.promise)
     .then(stop_trace)
     .then(function() {
       finishClient(gClient);
     });
 }
 function start_trace()
 {
   let deferred = promise.defer();
   gTraceClient.startTrace(["arguments", "return"], null, function() { deferred.resolve(); });
   return deferred.promise;
 }
 function eval_code()
 {
   gDebuggee.eval("(" + function() {
     function identity(x) {
       return x;
     }
     let circular = {};
     circular.self = circular;
     // Make sure there is only 3 properties per object because that is the value
     // of MAX_PROPERTIES in the server.
     let obj = {
       num: 0,
       str: "foo",
       bool: false,
     };
     let obj2 = {
       undef: undefined,
       nil: null,
       inf: Infinity
     };
     let obj3 = {
       ninf: -Infinity,
       nan: NaN,
       nzero: -0
     };
     let obj4 = {
       obj: circular,
       arr: [1,2,3,4,5]
     };
     identity();
     identity(0);
     identity("");
     identity(false);
     identity(undefined);
     identity(null);
     identity(Infinity);
     identity(-Infinity);
     identity(NaN);
     identity(-0);
     identity(obj);
     identity(obj2);
     identity(obj3);
     identity(obj4);
   } + ")()");
 }
 function stop_trace()
 {
   let deferred = promise.defer();
   gTraceClient.stopTrace(null, function() { deferred.resolve(); });
   return deferred.promise;
 }
 function check_trace(aTrace)
 {
   let value = (aTrace.type === "enteredFrame" && aTrace.arguments)
         ? aTrace.arguments[0]
         : aTrace.return;
   switch(aTrace.sequence) {
   case 2:
     do_check_eq(typeof aTrace.arguments, "object");
     do_check_eq(aTrace.arguments.length, 0);
     break;
   case 3:
     check_value(value, "object", "undefined");
     break;
   case 4:
   case 5:
     check_value(value, "number", 0);
     break;
   case 6:
   case 7:
     check_value(value, "string", "");
     break;
   case 8:
   case 9:
     check_value(value, "boolean", false);
     break;
   case 10:
   case 11:
     check_value(value, "object", "undefined");
     break;
   case 12:
   case 13:
     check_value(value, "object", "null");
     break;
   case 14:
   case 15:
     check_value(value, "object", "Infinity");
     break;
   case 16:
   case 17:
     check_value(value, "object", "-Infinity");
     break;
   case 18:
   case 19:
     check_value(value, "object", "NaN");
     break;
   case 20:
   case 21:
     check_value(value, "object", "-0");
     break;
   case 22:
   case 23:
     check_obj(aTrace.type, value);
     break;
   case 24:
   case 25:
     check_obj2(aTrace.type, value);
     break;
   case 26:
   case 27:
     check_obj3(aTrace.type, value);
     break;
   case 28:
   case 29:
     check_obj4(aTrace.type, value);
     break;
   }
 }
 function check_value(aActual, aExpectedType, aExpectedValue)
 {
   do_check_eq(typeof aActual, aExpectedType);
   do_check_eq(aExpectedType === "object" ? aActual.type : aActual, aExpectedValue);
 }
 function check_obj(aType, aObj) {
   do_check_eq(typeof aObj, "object");
   do_check_eq(typeof aObj.ownProperties, "object");
   do_check_eq(typeof aObj.ownProperties.num, "object");
   do_check_eq(aObj.ownProperties.num.value, 0);
   do_check_eq(typeof aObj.ownProperties.str, "object");
   do_check_eq(aObj.ownProperties.str.value, "foo");
   do_check_eq(typeof aObj.ownProperties.bool, "object");
   do_check_eq(aObj.ownProperties.bool.value, false);
 }
 function check_obj2(aType, aObj) {
   do_check_eq(typeof aObj.ownProperties.undef, "object");
   do_check_eq(typeof aObj.ownProperties.undef.value, "object");
   do_check_eq(aObj.ownProperties.undef.value.type, "undefined");
   do_check_eq(typeof aObj.ownProperties.nil, "object");
   do_check_eq(typeof aObj.ownProperties.nil.value, "object");
   do_check_eq(aObj.ownProperties.nil.value.type, "null");
   do_check_eq(typeof aObj.ownProperties.inf, "object");
   do_check_eq(typeof aObj.ownProperties.inf.value, "object");
   do_check_eq(aObj.ownProperties.inf.value.type, "Infinity");
 }
 function check_obj3(aType, aObj) {
   do_check_eq(typeof aObj.ownProperties.ninf, "object");
   do_check_eq(typeof aObj.ownProperties.ninf.value, "object");
   do_check_eq(aObj.ownProperties.ninf.value.type, "-Infinity");
   do_check_eq(typeof aObj.ownProperties.nan, "object");
   do_check_eq(typeof aObj.ownProperties.nan.value, "object");
   do_check_eq(aObj.ownProperties.nan.value.type, "NaN");
   do_check_eq(typeof aObj.ownProperties.nzero, "object");
   do_check_eq(typeof aObj.ownProperties.nzero.value, "object");
   do_check_eq(aObj.ownProperties.nzero.value.type, "-0");
 }
 function check_obj4(aType, aObj) {
   // Sub-objects aren't added.
   do_check_eq(typeof aObj.ownProperties.obj, "undefined");
   do_check_eq(typeof aObj.ownProperties.arr, "undefined");
 }