The Tor Browser: dom/events/test/test_bug822898.html@129ffea94266

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 <!DOCTYPE HTML>

     2 <html>

     3 <!--

     4 https://bugzilla.mozilla.org/show_bug.cgi?id=822898

     5 -->

     6 <head>

     7   <title>Test for Bug 822898</title>

     8   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>

     9   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />

    10 </head>

    11 <body>

    12 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=822898">Mozilla Bug 822898</a>

    13 <p id="display"></p>

    14 <div id="content" style="display: none">

    15   <iframe id="subFrame"></iframe>

    16 </div>

    17 <pre id="test">

    18 <script class="testbody" type="application/javascript;version=1.8">

    20 /** Test for Bug 822898 - Pointer* Events **/

    22 let tests = [], testTarget, parent, iframeBody, gOnPointerPropHandled;

    24 function nextTest() {

    25   if (tests.length)

    26     SimpleTest.executeSoon(tests.shift());

    27 }

    29 function random() {

    30   return Math.floor(Math.random() * 100);

    31 }

    33 function createTestEventValue(name) {

    35   let detail = random();

    36   let screenX = random();

    37   let screenY = random();

    38   let clientX = random();

    39   let clientY = random();

    40   let ctrlKey = random() % 2 ? true : false;

    41   let altKey = random() % 2 ? true : false;

    42   let shiftKey = random() % 2 ? true : false;

    43   let metaKey = random() % 2 ? true : false;

    44   let button = random();

    45   let pointerId = random();

    47   return function() {

    48     let event = new PointerEvent("pointerdown", {

    49       bubbles: true, cancelable: true, view: window,

    50       detail: detail, screenX: screenX, screenY: screenY, clientX: clientX, clientY: clientY,

    51       ctrlKey: ctrlKey, altKey: altKey, shiftKey: shiftKey, metaKey: metaKey,

    52       button: button, relatedTarget: null, pointerId: pointerId

    53     });

    56     function check(ev) {

    57       is(ev.detail, detail, "Correct detail");

    58       is(ev.screenX, screenX, "Correct screenX");

    59       is(ev.screenY, screenY, "Correct screenY");

    60       is(ev.clientX, clientX, "Correct clientX");

    61       is(ev.clientY, clientY, "Correct clientY");

    62       is(ev.ctrlKey, ctrlKey, "Correct ctrlKey");

    63       is(ev.altKey, altKey, "Correct altKey");

    64       is(ev.shiftKey, shiftKey, "Correct shiftKey");

    65       is(ev.metaKey, metaKey, "Correct metaKey");

    66       is(ev.button, button, "Correct buttonArg");

    67       is(ev.pointerId, pointerId, "Correct pointerId");

    68     }

    70     for each (let target in [document, window, testTarget, parent])

    71       target.addEventListener(name, check, false);

    73     testTarget.dispatchEvent(event);

    75     for each (let target in [document, window, testTarget, parent])

    76       target.removeEventListener(name, check, false);

    79     nextTest();

    80   }

    81 }

    83 function getDefaultArgEvent(eventname) {

    84   return new PointerEvent(eventname, {

    85     bubbles: true, cancelable: true, view: window,

    86     detail: 0, screenX: 0, screenY: 0, clientX: 0, clientY: 0,

    87     ctrlKey: false, altKey: false, shiftKey: false, metaKey: false,

    88     button: 0, relatedTarget: null, pointerId: 0

    89   });

    90 }

    92 function testDefaultArg() {

    93   let event = getDefaultArgEvent("pointerdown");

    95   testTarget.addEventListener("pointerdown", function(ev) {

    96     testTarget.removeEventListener("pointerdown", arguments.callee, false);

    97     is(ev.pointerId, 0, "Correct default pointerId");

    98   }, false);

    99   testTarget.dispatchEvent(event);

   101   nextTest();

   102 }

   104 function testStopPropagation() {

   105   let event = getDefaultArgEvent("pointerdown");

   107   let unreachableListener = function () {

   108     ok(false, "Event should have been stopped");

   109   }

   111   // Capturing phase

   112   let captured = false;

   113   parent.addEventListener("pointerdown", function() {

   114     parent.removeEventListener("pointerdown", arguments.callee, true);

   115     captured = true;

   116   }, true); // Capturing phase

   118   // Bubbling phase

   119   parent.addEventListener("pointerdown", unreachableListener, false);

   121   testTarget.addEventListener("pointerdown", function(ev) {

   122     testTarget.removeEventListener("pointerdown", arguments.callee, false);

   123     is(captured, true, "Event should have been captured");

   124     ev.stopPropagation();

   125   }, false);

   127   testTarget.dispatchEvent(event);

   129   parent.removeEventListener("pointerdown", unreachableListener, false);

   131   nextTest();

   132 }

   134 function testPreventDefault() {

   135   let event = getDefaultArgEvent("pointerdown");

   137   parent.addEventListener("pointerdown", function(ev) {

   138     parent.removeEventListener("pointerdown", arguments.callee, false);

   139     is(ev.defaultPrevented, true, "preventDefault can be called");

   140     nextTest();

   141   }, false);

   143   testTarget.addEventListener("pointerdown", function(ev) {

   144     testTarget.removeEventListener("pointerdown", arguments.callee, false);

   145     ev.preventDefault();

   146   }, false);

   148   testTarget.dispatchEvent(event);

   149 }

   151 function testBlockPreventDefault() {

   152   let event = new PointerEvent("pointerdown", {

   153     bubbles: true, cancelable: false, view: window,

   154     detail: 0, screenX: 0, screenY: 0, clientX: 0, clientY: 0,

   155     ctrlKey: false, altKey: false, shiftKey: false, metaKey: false,

   156     button: 0, relatedTarget: null, pointerId: 0, pointerType: "pen"

   157   });

   159   parent.addEventListener("pointerdown", function(ev) {

   160     parent.removeEventListener("pointerdown", arguments.callee, false);

   161     is(ev.defaultPrevented, false, "aCancelableArg works");

   162     nextTest();

   163   }, false);

   165   testTarget.addEventListener("pointerdown", function(ev) {

   166     testTarget.removeEventListener("pointerdown", arguments.callee, false);

   167     ev.preventDefault();

   168   }, false);

   170   testTarget.dispatchEvent(event);

   171 }

   173 function testBlockBubbling() {

   174   let unreachableListener = function () {

   175     ok(false, "aCanBubble doesn't work");

   176   }

   178   let event = new PointerEvent("pointerdown", {

   179     bubbles: false, cancelable: true, view: window,

   180     detail: 0, screenX: 0, screenY: 0, clientX: 0, clientY: 0,

   181     ctrlKey: false, altKey: false, shiftKey: false, metaKey: false,

   182     button: 0, relatedTarget: null, pointerId: 0

   183   });

   185   parent.addEventListener("pointerdown", unreachableListener, false);

   186   testTarget.dispatchEvent(event);

   187   parent.removeEventListener("pointerdown", unreachableListener, false);

   189   nextTest();

   190 }

   192 function testOnPointerProperty()

   193 {

   194   iframeBody.onpointerdown = function (e) { gOnPointerPropHandled["pointerdown"] = true; }

   195   iframeBody.onpointerup = function (e) { gOnPointerPropHandled["pointerup"] = true; }

   196   iframeBody.onpointermove = function (e) { gOnPointerPropHandled["pointermove"] = true; }

   197   iframeBody.onpointerout = function (e) { gOnPointerPropHandled["pointerout"] = true; }

   198   iframeBody.onpointerover = function (e) { gOnPointerPropHandled["pointerover"] = true; }

   199   iframeBody.onpointerenter = function (e) { gOnPointerPropHandled["pointerenter"] = true; }

   200   iframeBody.onpointerleave = function (e) { gOnPointerPropHandled["pointerleave"] = true; }

   201   iframeBody.onpointercancel = function (e) { gOnPointerPropHandled["pointercancel"] = true; }

   203   iframeBody.dispatchEvent(getDefaultArgEvent("pointerdown"));

   204   is(gOnPointerPropHandled['pointerdown'], true, "pointerdown property is performed");

   206   iframeBody.dispatchEvent(getDefaultArgEvent("pointerup"));

   207   is(gOnPointerPropHandled['pointerup'], true, "pointerup property is performed");

   209   iframeBody.dispatchEvent(getDefaultArgEvent("pointermove"));

   210   is(gOnPointerPropHandled['pointermove'], true, "pointermove property is performed");

   212   iframeBody.dispatchEvent(getDefaultArgEvent("pointerout"));

   213   is(gOnPointerPropHandled['pointerout'], true, "pointerout property is performed");

   215   iframeBody.dispatchEvent(getDefaultArgEvent("pointerover"));

   216   is(gOnPointerPropHandled['pointerover'], true, "pointerover property is performed");

   218   iframeBody.dispatchEvent(getDefaultArgEvent("pointerenter"));

   219   is(gOnPointerPropHandled['pointerenter'], true, "pointerenter property is performed");

   221   iframeBody.dispatchEvent(getDefaultArgEvent("pointerleave"));

   222   is(gOnPointerPropHandled['pointerleave'], true, "pointerleave property is performed");

   224   iframeBody.dispatchEvent(getDefaultArgEvent("pointercancel"));

   225   is(gOnPointerPropHandled['pointercancel'], true, "pointercancel property is performed");

   227   nextTest();

   228 }

   230 function testPointerEventCTORS()

   231 {

   232   // TODO: This should go to test_eventctors.html, when PointerEvents enabled by default

   233   var receivedEvent;

   234   iframeBody.addEventListener("hello", function(e) { receivedEvent = e; }, true);

   236   var e;

   237   var ex = false;

   239   try {

   240     e = new PointerEvent();

   241   } catch(exp) {

   242     ex = true;

   243   }

   244   ok(ex, "PointerEvent: First parameter is required!");

   245   ex = false;

   247   e = new PointerEvent("hello");

   248   ok(e.type, "hello", "PointerEvent: Wrong event type!");

   249   ok(!e.isTrusted, "PointerEvent: Event shouldn't be trusted!");

   250   ok(!e.bubbles, "PointerEvent: Event shouldn't bubble!");

   251   ok(!e.cancelable, "PointerEvent: Event shouldn't be cancelable!");

   252   iframeBody.dispatchEvent(e);

   253   is(receivedEvent, e, "PointerEvent: Wrong event!");

   255   var PointerEventProps =

   256   [ { screenX: 0 },

   257     { screenY: 0 },

   258     { clientX: 0 },

   259     { clientY: 0 },

   260     { ctrlKey: false },

   261     { shiftKey: false },

   262     { altKey: false },

   263     { metaKey: false },

   264     { button: 0 },

   265     { buttons: 0 },

   266     { relatedTarget: null },

   267     { pointerId: 0 },

   268     { pointerType: "" }

   269   ];

   271   var testPointerProps =

   272   [

   273     { screenX: 1 },

   274     { screenY: 2 },

   275     { clientX: 3 },

   276     { clientY: 4 },

   277     { ctrlKey: true },

   278     { shiftKey: true },

   279     { altKey: true },

   280     { metaKey: true },

   281     { button: 5 },

   282     { buttons: 6 },

   283     { relatedTarget: window },

   284     { pointerId: 5 },

   285     { pointerType: "mouse" }

   286   ];

   288   var defaultPointerEventValues = {};

   289   for (var i = 0; i < PointerEventProps.length; ++i) {

   290     for (prop in PointerEventProps[i]) {

   291       ok(prop in e, "PointerEvent: PointerEvent doesn't have property " + prop + "!");

   292       defaultPointerEventValues[prop] = PointerEventProps[i][prop];

   293     }

   294   }

   296   while (testPointerProps.length) {

   297     var p = testPointerProps.shift();

   298     e = new PointerEvent("foo", p);

   299     for (var def in defaultPointerEventValues) {

   300       if (!(def in p)) {

   301         is(e[def], defaultPointerEventValues[def],

   302            "PointerEvent: Wrong default value for " + def + "!");

   303       } else {

   304         is(e[def], p[def], "PointerEvent: Wrong event init value for " + def + "!");

   305       }

   306     }

   307   }

   308   nextTest();

   309 }

   311 function runTests() {

   312   SpecialPowers.setBoolPref("dom.w3c_pointer_events.enabled", true);      // Enable Pointer Events

   313   testTarget = document.getElementById("testTarget");

   314   parent = testTarget.parentNode;

   315   gOnPointerPropHandled = new Array;

   316   iframeBody = document.getElementById("subFrame").contentWindow.document.body;

   318   tests.push(createTestEventValue("pointerdown"));

   319   tests.push(createTestEventValue("pointermove"));

   320   tests.push(createTestEventValue("pointerup"));

   322   tests.push(testDefaultArg);

   323   tests.push(testStopPropagation);

   325   tests.push(testPreventDefault);

   326   tests.push(testBlockPreventDefault);

   328   tests.push(testBlockBubbling);

   329   tests.push(testOnPointerProperty());

   330   tests.push(testPointerEventCTORS());

   332   tests.push(function() {

   333     clearPrefs();

   334     SimpleTest.finish();

   335   });

   337   nextTest();

   338 }

   340 function initPrefs()

   341 {

   342   SpecialPowers.setBoolPref("dom.w3c_pointer_events.enabled", true);      // Enable Pointer Events

   343 }

   345 function clearPrefs()

   346 {

   347   SpecialPowers.clearUserPref("dom.w3c_pointer_events.enabled");      // Disable Pointer Events

   348 }

   350 window.onload = function () {

   351   initPrefs();

   352   SimpleTest.executeSoon(runTests);

   353 }

   355 SimpleTest.waitForExplicitFinish();

   357 </script>

   358 </pre>

   359 <div id="parent">

   360   <span id="testTarget" style="border: 1px solid black;">testTarget</span>

   361 </div>

   362 </body>

   363 </html>

The Tor Browser / file revision

dom/events/test/test_bug822898.html@129ffea94266

dom/events/test/test_bug822898.html