The Tor Browser: js/src/tests/js1_8_5/extensions/shell.js@129ffea94266 (annotated)

js/src/tests/js1_8_5/extensions/shell.js@129ffea94266 (annotated)

js/src/tests/js1_8_5/extensions/shell.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.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 // The Worker constructor can take a relative URL, but different test runners
 // run in different enough environments that it doesn't all just automatically
 // work. For the shell, we use just a filename; for the browser, see browser.js.
 var workerDir = '';
 // explicitly turn on js185
 // XXX: The browser currently only supports up to version 1.8
 if (typeof version != 'undefined')
 {
   version(185);
 }
 // A little pattern-matching library.
 var Match =
 (function() {
     function Pattern(template) {
         // act like a constructor even as a function
         if (!(this instanceof Pattern))
             return new Pattern(template);
         this.template = template;
     }
     Pattern.prototype = {
         match: function(act) {
             return match(act, this.template);
         },
         matches: function(act) {
             try {
                 return this.match(act);
             }
             catch (e if e instanceof MatchError) {
                 return false;
             }
         },
         assert: function(act, message) {
             try {
                 return this.match(act);
             }
             catch (e if e instanceof MatchError) {
                 throw new Error((message || "failed match") + ": " + e.message);
             }
         },
         toString: function() "[object Pattern]"
     };
     Pattern.ANY = new Pattern;
     Pattern.ANY.template = Pattern.ANY;
     var quote = uneval;
     function MatchError(msg) {
         this.message = msg;
     }
     MatchError.prototype = {
         toString: function() {
             return "match error: " + this.message;
         }
     };
     function isAtom(x) {
         return (typeof x === "number") ||
             (typeof x === "string") ||
             (typeof x === "boolean") ||
             (x === null) ||
             (typeof x === "object" && x instanceof RegExp);
     }
     function isObject(x) {
         return (x !== null) && (typeof x === "object");
     }
     function isArrayLike(x) {
         return isObject(x) && ("length" in x);
     }
     function matchAtom(act, exp) {
         if ((typeof exp) === "number" && isNaN(exp)) {
             if ((typeof act) !== "number" || !isNaN(act))
                 throw new MatchError("expected NaN, got: " + quote(act));
             return true;
         }
         if (exp === null) {
             if (act !== null)
                 throw new MatchError("expected null, got: " + quote(act));
             return true;
         }
         if (exp instanceof RegExp) {
             if (!(act instanceof RegExp) || exp.source !== act.source)
                 throw new MatchError("expected " + quote(exp) + ", got: " + quote(act));
             return true;
         }
         switch (typeof exp) {
         case "string":
             if (act !== exp)
                 throw new MatchError("expected " + exp.quote() + ", got " + quote(act));
             return true;
         case "boolean":
         case "number":
             if (exp !== act)
                 throw new MatchError("expected " + exp + ", got " + quote(act));
             return true;
         }
         throw new Error("bad pattern: " + exp.toSource());
     }
     function matchObject(act, exp) {
         if (!isObject(act))
             throw new MatchError("expected object, got " + quote(act));
         for (var key in exp) {
             if (!(key in act))
                 throw new MatchError("expected property " + key.quote() + " not found in " + quote(act));
             match(act[key], exp[key]);
         }
         return true;
     }
     function matchArray(act, exp) {
         if (!isObject(act) || !("length" in act))
             throw new MatchError("expected array-like object, got " + quote(act));
         var length = exp.length;
         if (act.length !== exp.length)
             throw new MatchError("expected array-like object of length " + length + ", got " + quote(act));
         for (var i = 0; i < length; i++) {
             if (i in exp) {
                 if (!(i in act))
                     throw new MatchError("expected array property " + i + " not found in " + quote(act));
                 match(act[i], exp[i]);
             }
         }
         return true;
     }
     function match(act, exp) {
         if (exp === Pattern.ANY)
             return true;
         if (exp instanceof Pattern)
             return exp.match(act);
         if (isAtom(exp))
             return matchAtom(act, exp);
         if (isArrayLike(exp))
             return matchArray(act, exp);
         return matchObject(act, exp);
     }
     return { Pattern: Pattern,
              MatchError: MatchError };
 })();
 function referencesVia(from, edge, to) {
     edge = "edge: " + edge;
     var edges = findReferences(to);
     if (edge in edges && edges[edge].indexOf(from) != -1)
         return true;
     // Be nice: make it easy to fix if the edge name has just changed.
     var alternatives = [];
     for (var e in edges) {
         if (edges[e].indexOf(from) != -1)
             alternatives.push(e);
     }
     if (alternatives.length == 0) {
         print("referent not referred to by referrer after all");
     } else {
         print("referent is not referenced via: " + uneval(edge));
         print("but it is referenced via:       " + uneval(alternatives));
     }
     print("all incoming edges, from any object:");
     for (var e in edges)
         print(e);
     return false;
 }
 // Note that AsmJS ArrayBuffers have a minimum size, currently 4096 bytes. If a
 // smaller size is given, a regular ArrayBuffer will be returned instead.
 function AsmJSArrayBuffer(size) {
     var ab = new ArrayBuffer(size);
     (new Function('global', 'foreign', 'buffer', '' +
 '        "use asm";' +
 '        var i32 = new global.Int32Array(buffer);' +
 '        function g() {};' +
 '        return g;' +
 ''))(Function("return this")(),null,ab);
     return ab;
 }