The Tor Browser: js/xpconnect/tests/chrome/test_cows.xul@129ffea94266 (annotated)

js/xpconnect/tests/chrome/test_cows.xul@129ffea94266 (annotated)

js/xpconnect/tests/chrome/test_cows.xul

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.

 <?xml version="1.0"?>
 <?xml-stylesheet href="chrome://global/skin" type="text/css"?>
 <?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
                  type="text/css"?>
 <!--
 https://bugzilla.mozilla.org/show_bug.cgi?id=500931
 -->
 <window title="Mozilla Bug 522764"
   xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
   <script type="application/javascript"
           src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
   <!-- test results are displayed in the html:body -->
   <body xmlns="http://www.w3.org/1999/xhtml">
   <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=522764 "
      target="_blank">Mozilla Bug 522764 </a>
   </body>
   <!-- test code goes here -->
   <script type="application/javascript"><![CDATA[
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 var sandbox = new Cu.Sandbox("about:blank");
 var test_utils = window.QueryInterface(Ci.nsIInterfaceRequestor).
                  getInterface(Ci.nsIDOMWindowUtils);
 function getCOW(x) {
   if (typeof x != 'object' && typeof x != 'function')
     return x;
   var rval = {};
   if (typeof x == "function")
     rval = eval(uneval(x));
   for (var i in x) {
     if (x.__lookupGetter__(i))
       rval.__defineGetter__(i, eval(uneval(x.__lookupGetter__(i))))
     else
       rval[i] = getCOW(x[i]);
   }
   return rval;
 }
 // Give the sandbox a way to create ChromeObjectWrapped objects.
 sandbox.getCOW = getCOW;
 // Define test API functions in the sandbox.
 const TEST_API = ['is', 'isnot', 'ok', 'todo_is', 'todo_isnot', 'todo'];
 TEST_API.forEach(function(name) { sandbox[name] = window[name]; });
 sandbox.alienObject = {
   __exposedProps__: {funProp: 'r'},
   funProp: function foo(x) {
     return x + 1;
   }
 };
 sandbox.chromeGet = function (obj, prop) { return obj[prop]; };
 function COWTests() {
     // This function is actually decompiled and run inside a
     // sandbox with content privileges.
     // TODO: This could use some refactoring; creating helper
     // functions like assertIsWritable(myObj, 'someproperty') might
     // be useful.
     function isProp(obj, propName, value, desc) {
       try {
           is(obj[propName], value, "getting " + propName + " on " + desc);
           ok(propName in obj,
              propName + " on " + desc + " should exist");
           ok(Object.hasOwnProperty.call(obj, propName),
              propName + " on " + desc + " should exist");
       } catch (e) {
           ok(false, "getting " + propName + " on " + desc + " threw " + e);
       }
     }
     function isPropHidden(obj, propName, desc) {
       try {
           is(obj[propName], undefined,
              "getting " + propName + " on " + desc + " should return undefined");
           ok(!(propName in obj),
              propName + " on " + desc + " should act as if it doesn't exist");
           ok(!Object.hasOwnProperty.call(obj, propName),
              propName + " on " + desc + " should act as if it doesn't exist");
       } catch (e) {
           ok(false, "getting " + propName + " on " + desc + " threw " + e);
       }
     }
     const PROPS_TO_TEST = ['foo', 'bar', 'prototype'];
     var empty = {};
     var nonempty = {foo: 42, bar: 33};
     is(getCOW(empty).foo, undefined,
        "shouldn't throw when accessing exposed properties that doesn't exist");
     PROPS_TO_TEST.forEach(function(name) {
         isPropHidden(getCOW(nonempty), name, "object without exposedProps");
     });
     // Test function objects without __exposedProps__
     var func = function(x) { return 42; };
     func.foo = "foo property";
     var funcCOW = getCOW(func);
     PROPS_TO_TEST.forEach(function(name) {
         isPropHidden(funcCOW, name, "function without exposedProps");
     });
     is([name for (name in funcCOW)].length, 0,
        "function without exposedProps shouldn't have any properties");
     is(funcCOW(), 42, "COW without exposedProps should still be callable");
     // Test function objects with __exposedProps__
     var func = function(x) { return 42; };
     func.foo = "foo property";
     func.__exposedProps__ = { foo: "r" };
     var funcCOWr = getCOW(func);
     PROPS_TO_TEST.forEach(function(name) {
         if (name == "foo") {
             isProp(funcCOWr, name, "foo property",
                    "function with exposedProps");
         }
         else {
             isPropHidden(funcCOWr, name, "function with exposedProps");
         }
     });
     is([name for (name in funcCOWr)].length, 1,
        "function with exposedProps should only enumerate exposed props");
     is([name for (name in funcCOWr)][0], "foo",
        "function with exposedProps should only enumerate exposed props");
     is(funcCOWr(), 42, "COW with exposedProps should be callable");
     // Test function objects with __exposedProps__
     var func = function(x) { return 42; };
     func.foo = "foo property";
     func.__exposedProps__ = { foo: "r", bar: "r" };
     var funcCOWr2 = getCOW(func);
     PROPS_TO_TEST.forEach(function(name) {
         if (name == "foo") {
             isProp(funcCOWr2, name, "foo property",
                    "function with more exposedProps");
         }
         else {
             isPropHidden(funcCOWr2, name, "function with more exposedProps");
         }
     });
     is([name for (name in funcCOWr2)].length, 1,
        "function with exposedProps should only enumerate exposed props");
     is([name for (name in funcCOWr2)][0], "foo",
        "function with exposedProps should only enumerate exposed props");
     // Test object with empty exposedProps
     var strict = { __exposedProps__: {}, foo: "foo property" };
     var strictCOW = getCOW(strict);
     PROPS_TO_TEST.forEach(function(name) {
         isPropHidden(strictCOW, name, "object with empty exposedProps");
     });
     is([name for (name in strictCOW)].length, 0,
        "object with empty exposedProps shouldn't have any properties");
     // Test object with one exposed property
     var strict = { __exposedProps__: { foo: "r" }, foo: "foo property" };
     var strictCOWr = getCOW(strict);
     PROPS_TO_TEST.forEach(function(name) {
         if (name == "foo") {
             isProp(strictCOWr, name, "foo property",
                    "object with exposed 'foo'");
         }
         else {
             isPropHidden(strictCOW, name, "object with exposed 'foo'");
         }
     });
     is([name for (name in strictCOWr)].length, 1,
        "object with exposedProps only enumerate exposed props");
     is([name for (name in strictCOWr)][0], "foo",
        "object with exposedProps only enumerate exposed props");
     // Test writable property
     var writable = getCOW({ __exposedProps__: {foo: 'w'}});
     try {
         ok(!("foo" in writable),
            "non-existing write-only property shouldn't exist");
         writable.foo = 5;
         is(chromeGet(writable, "foo"), 5, "writing to a write-only exposed prop works");
         todo("foo" in writable,
              "existing write-only property should exist");
     } catch (e) {
         ok(false, "writing to a write-only exposed prop shouldn't throw " + e);
     }
     try {
         writable.foo;
         todo(false, "reading from a write-only exposed prop should throw");
     } catch (e) {
         todo(/Permission denied/.test(e),
              "reading from a write-only exposed prop should throw");
     }
     try {
         delete writable.foo;
         is(chromeGet(writable, "foo"), undefined,
            "deleting a write-only exposed prop works");
     } catch (e) {
         ok(false, "deleting a write-only exposed prop shouldn't throw " + e);
     }
     // Test readable property
     var readable = { __exposedProps__: {foo: 'r'},
                      foo: 5,
                      bar: 6 };
     try {
         isProp(getCOW(readable), "foo", 5,
                "reading from a readable exposed prop works");
     } catch (e) {
         ok(false, "reading from a readable exposed prop shouldn't throw " + e);
     }
     try {
         getCOW(readable).foo = 1;
         ok(false, "writing to a read-only exposed prop should fail");
     } catch (e) {
         ok(/Permission denied/.test(e),
            "writing to a read-only exposed prop should fail");
     }
     try {
         delete getCOW(readable).foo;
         ok(false, "deleting a read-only exposed prop shouldn't work");
     } catch (e) {
         ok(/Permission denied/.test(e),
            "deleting a read-only exposed prop should throw error");
     }
     try {
         var props = [name for (name in getCOW(readable))];
         is(props.length, 1, "COW w/ one exposed prop should enumerate once");
         is(props[0], 'foo', "COW w/ one exposed prop should enumerate it");
     } catch (e) {
         ok(false, "COW w/ a readable prop should not raise exc " +
                   "on enumeration: " + e);
     }
     // Test read/write property
     var readwrite = getCOW({ __exposedProps__: {foo: 'rw'}});
     try {
         ok(!("foo" in readwrite),
            "non-existing readwrite property shouldn't exist");
         readwrite.foo = 5;
         is(readwrite.foo, 5, "writing to a readwrite exposed prop looks like it worked");
         is(chromeGet(readwrite, "foo"), 5, "writing to a readwrite exposed prop works");
         ok("foo" in readwrite,
            "existing readwrite property should exist");
     } catch (e) {
         ok(false, "writing to a readwrite exposed prop shouldn't throw " + e);
     }
     try {
         delete readwrite.foo;
         is(readwrite.foo, undefined, "deleting readwrite prop looks like it worked");
         ok(!("foo" in readwrite), "deleting readwrite prop looks like it really worked");
         is(chromeGet(readwrite, "foo"), undefined,
            "deleting a readwrite exposed prop works");
     } catch (e) {
         ok(false, "deleting a readwrite exposed prop shouldn't throw " + e);
     }
     // Readables and functions
     try {
         var COWFunc = getCOW((function() { return 5; }));
         is(COWFunc(), 5, "COWed functions should be callable");
     } catch (e) {
         todo(false, "COWed functions should not raise " + e);
     }
     try {
         var objWithFunc = {__exposedProps__: {foo: 'r'},
                            foo: function foo() { return 5; }};
         is(getCOW((objWithFunc)).foo(), 5,
            "Readable function exposed props should be callable");
     } catch (e) {
         ok(false, "Readable function exposed props should be callable" + e);
     }
     // Readables with getters
     var obj = {
         get prop() { return { __exposedProps__: {}, test: "FAIL" } },
         __exposedProps__: {prop: 'r'}
     };
     is(getCOW(obj).prop.test, undefined, "getting prop.test shouldn't return anything");
     ok(!("test" in getCOW(obj).prop), "getting prop.test shouldn't return anything");
     // Alien objects
     try {
         is(alienObject.funProp(1), 2,
            "COWs wrapping objects from different principals should work");
     } catch (e) {
         ok(false, "COWs wrapping objs from different principals " +
                   "shouldn't throw " + e);
     }
     try {
         is(alienObject.funProp(1), 2,
            "COWs wrapping objs from different principals should work twice");
     } catch (e) {
         ok(false, "COWs wrapping objs from different principals " +
                   "shouldn't throw on second access but not first: " + e);
     }
 }
 // Decompile the COW test suite, re-evaluate it in the sandbox and execute it.
 Cu.evalInSandbox('(' + uneval(COWTests) + ')()', sandbox);
 // Test that COWed objects passing from content to chrome get unwrapped.
 function returnCOW() {
     return getCOW({__exposedProps__: {},
                   bar: 6});
 }
 var unwrapped = Cu.evalInSandbox(
     '(' + uneval(returnCOW) + ')()',
     sandbox
 );
 try {
     is(unwrapped.bar, 6,
        "COWs should be unwrapped when entering chrome space");
 } catch (e) {
     todo(false, "COWs should be unwrapped when entering chrome space, " +
                 "not raise " + e);
 }
   ]]></script>
 </window>

The Tor Browser / annotate

js/xpconnect/tests/chrome/test_cows.xul@129ffea94266 (annotated)

js/xpconnect/tests/chrome/test_cows.xul