The Tor Browser: dom/indexedDB/test/event_propagation

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.

     1 <!--

     2   Any copyright is dedicated to the Public Domain.

     3   http://creativecommons.org/publicdomain/zero/1.0/

     4 -->

     5 <html>

     6 <head>

     7   <title>Indexed Database Property Test</title>

     9   <script type="text/javascript;version=1.7">

    11     let testGenerator = testSteps();

    13     function ok(val, message) {

    14       val = val ? "true" : "false";

    15       window.parent.postMessage("SimpleTest.ok(" + val + ", '" + message +

    16                                 "');", "*");

    17     }

    19     function grabEventAndContinueHandler(event) {

    20       testGenerator.send(event);

    21     }

    23     function errorHandler(event) {

    24       ok(false, "indexedDB error, code " + event.target.error.name);

    25       finishTest();

    26     }

    28     function finishTest() {

    29       // Let window.onerror have a chance to fire

    30       setTimeout(function() {

    31         setTimeout(function() {

    32           testGenerator.close();

    33           ok(windowErrorCount == 1, "Good window.onerror count");

    34           window.parent.postMessage("SimpleTest.finish();", "*");

    35         }, 0);

    36       }, 0);

    37     }

    39     const eventChain = [

    40       "IDBRequest",

    41       "IDBTransaction",

    42       "IDBDatabase"

    43     ];

    45     let captureCount = 0;

    46     let bubbleCount = 0;

    47     let atTargetCount = 0;

    48     let windowErrorCount = 0;

    50     window.onerror = function(event) {

    51       ok(!windowErrorCount++, "Correct number of window.onerror events");

    52       setTimeout(function() { testGenerator.next(); }, 0);

    53     };

    55     function errorEventCounter(event) {

    56       ok(event.type == "error", "Got an error event");

    57       ok(event.target instanceof window[eventChain[0]],

    58          "Correct event.target");

    60       let constructor;

    61       if (event.eventPhase == event.AT_TARGET) {

    62         atTargetCount++;

    63         constructor = eventChain[0];

    64       }

    65       else if (event.eventPhase == event.CAPTURING_PHASE) {

    66         constructor = eventChain[eventChain.length - 1 - captureCount++];

    67       }

    68       else if (event.eventPhase == event.BUBBLING_PHASE) {

    69         constructor = eventChain[++bubbleCount];

    70         if (windowErrorCount && bubbleCount == eventChain.length - 1) {

    71           event.preventDefault();

    72         }

    73       }

    74       ok(event.currentTarget instanceof window[constructor],

    75          "Correct event.currentTarget");

    77       if (bubbleCount == eventChain.length - 1) {

    78         ok(bubbleCount == captureCount,

    79            "Got same number of calls for both phases");

    80         ok(atTargetCount == 1, "Got one atTarget event");

    82         captureCount = bubbleCount = atTargetCount = 0;

    83         if (windowErrorCount) {

    84           finishTest();

    85         }

    86       }

    87     }

    89     function testSteps() {

    90       let request = indexedDB.open(window.location.pathname, 1);

    91       request.onerror = errorHandler;

    92       request.onupgradeneeded = grabEventAndContinueHandler;

    93       let event = yield undefined;

    95       let db = event.target.result;

    96       db.onerror = errorEventCounter;

    97       db.addEventListener("error", errorEventCounter, true);

    99       event.target.onsuccess = grabEventAndContinueHandler;

   101       db.createObjectStore("foo", { autoIncrement: true });

   102       yield undefined;

   104       let transaction = db.transaction("foo", "readwrite");

   105       transaction.addEventListener("error", errorEventCounter, false);

   106       transaction.addEventListener("error", errorEventCounter, true);

   108       let objectStore = transaction.objectStore("foo");

   110       request = objectStore.add({}, 1);

   111       request.onsuccess = grabEventAndContinueHandler;

   112       request.onerror = errorHandler;

   113       event = yield undefined;

   115       request = objectStore.add({}, 1);

   116       request.onsuccess = function(event) {

   117         ok(false, "Did not expect second add to succeed.");

   118       };

   119       request.onerror = errorEventCounter;

   120       yield undefined;

   122       transaction = db.transaction("foo", "readwrite");

   123       transaction.addEventListener("error", errorEventCounter, false);

   124       transaction.addEventListener("error", errorEventCounter, true);

   126       objectStore = transaction.objectStore("foo");

   128       request = objectStore.add({}, 1);

   129       request.onsuccess = grabEventAndContinueHandler;

   130       request.onerror = errorHandler;

   131       event = yield undefined;

   133       request = objectStore.add({}, 1);

   134       request.onsuccess = function(event) {

   135         ok(false, "Did not expect second add to succeed.");

   136       };

   137       request.onerror = errorEventCounter;

   138       yield undefined;

   139     }

   140   </script>

   142 </head>

   144 <body onload="testGenerator.next();"></body>

   146 </html>

The Tor Browser / file revision

dom/indexedDB/test/event_propagation_iframe.html@129ffea94266

dom/indexedDB/test/event_propagation_iframe.html