author Masayuki Nakano <masayuki@d-toybox.com>

Fri, 02 Feb 2018 18:10:22 +0900

changeset 750479 0f9d29f3c451a16f30f1b949bb44d175cda16334

parent 750383 27e993937c984b0e2bd05aeb17d791c7c036ad21

push id 97677

push user masayuki@d-toybox.com

push date Fri, 02 Feb 2018 12:08:46 +0000

reviewers smaug

bugs 1435180

milestone 60.0a1

browser/base/content/test/permissions/browser_permissions.js file | annotate | diff | comparison | revisions

browser/base/content/test/permissions/permissions.html file | annotate | diff | comparison | revisions

browser/components/resistfingerprinting/test/browser/browser_spoofing_keyboard_event.js file | annotate | diff | comparison | revisions

devtools/client/shared/test/browser_treeWidget_keyboard_interaction.js file | annotate | diff | comparison | revisions

dom/events/test/test_dom_keyboard_event.html file | annotate | diff | comparison | revisions

dom/html/test/browser_fullscreen-api-keys.js file | annotate | diff | comparison | revisions

dom/html/test/forms/test_input_number_key_events.html file | annotate | diff | comparison | revisions

dom/html/test/test_bug1295719_event_sequence_for_arrow_keys.html file | annotate | diff | comparison | revisions

dom/html/test/test_bug633058.html file | annotate | diff | comparison | revisions

layout/forms/test/test_bug935876.html file | annotate | diff | comparison | revisions

testing/mochitest/tests/Harness_sanity/test_sanityEventUtils.html file | annotate | diff | comparison | revisions
--- a/browser/base/content/test/permissions/browser_permissions.js
+++ b/browser/base/content/test/permissions/browser_permissions.js
@@ -1,13 +1,15 @@
 /*
  * Test the Permissions section in the Control Center.
  */
 
 const PERMISSIONS_PAGE  = getRootDirectory(gTestPath).replace("chrome://mochitests/content", "https://example.com") + "permissions.html";
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
 
 function openIdentityPopup() {
   let promise = BrowserTestUtils.waitForEvent(gIdentityHandler._identityPopup, "popupshown");
   gIdentityHandler._identityBox.click();
   return promise;
 }
 
 function closeIdentityPopup() {
@@ -183,19 +185,25 @@ add_task(async function testPermissionSh
 
     await new Promise(r => {
       SpecialPowers.pushPrefEnv({"set": [["permissions.default.shortcuts", 0]]}, r);
     });
 
     async function tryKey(desc, expectedValue) {
       await EventUtils.synthesizeAndWaitKey("c", { accelKey: true });
       let result = await ContentTask.spawn(browser, null, function() {
-        return content.wrappedJSObject.gKeyPresses;
+        return {keydowns: content.wrappedJSObject.gKeyDowns,
+                keypresses: content.wrappedJSObject.gKeyPresses};
       });
-      is(result, expectedValue, desc);
+      is(result.keydowns, expectedValue, "keydown event was fired or not fired as expected, " + desc);
+      if (kStrictKeyPressEvents) {
+        is(result.keypresses, 0, "keypress event shouldn't be fired for shortcut key, " + desc);
+      } else {
+        is(result.keypresses, expectedValue, "keypress event should be fired even for shortcut key, " + desc);
+      }
     }
 
     await tryKey("pressed with default permissions", 1);
 
     SitePermissions.set(gBrowser.currentURI, "shortcuts", SitePermissions.BLOCK);
     await tryKey("pressed when site blocked", 1);
 
     SitePermissions.set(gBrowser.currentURI, "shortcuts", SitePermissions.ALLOW);
--- a/browser/base/content/test/permissions/permissions.html
+++ b/browser/base/content/test/permissions/permissions.html
@@ -2,17 +2,18 @@
 <!-- This Source Code Form is subject to the terms of the Mozilla Public
    - License, v. 2.0. If a copy of the MPL was not distributed with this
    - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
 <html dir="ltr" xml:lang="en-US" lang="en-US">
   <head>
     <meta charset="utf8">
   </head>
 <script>
+var gKeyDowns = 0;
 var gKeyPresses = 0;
 </script>
-  <body onkeypress="gKeyPresses++;">
+  <body onkeydown="gKeyDowns++;" onkeypress="gKeyPresses++">
 	<!-- This page could eventually request permissions from content
 	     and make sure that chrome responds appropriately -->
   <button id="geo" onclick="navigator.geolocation.getCurrentPosition(() => {})">Geolocation</button>
   <button id="camera" onclick="navigator.mediaDevices.getUserMedia({video: true, fake: true})">Camera</button>
   </body>
 </html>
--- a/browser/components/resistfingerprinting/test/browser/browser_spoofing_keyboard_event.js
+++ b/browser/components/resistfingerprinting/test/browser/browser_spoofing_keyboard_event.js
@@ -1,69 +1,74 @@
 /**
  * Bug 1222285 - A test case for testing whether keyboard events be spoofed correctly
  *   when fingerprinting resistance is enable.
  */
 
 const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu } = Components;
 
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 const nsIDOMKeyEvent = Ci.nsIDOMKeyEvent;
 const SHOULD_DELIVER_KEYDOWN          = 0x1;
 const SHOULD_DELIVER_KEYPRESS         = 0x2;
 const SHOULD_DELIVER_KEYUP            = 0x4;
-const SHOULD_DELIVER_ALL              = SHOULD_DELIVER_KEYDOWN |
-                                        SHOULD_DELIVER_KEYPRESS |
-                                        SHOULD_DELIVER_KEYUP;
+const SHOULD_DELIVER_ALL_FOR_PRINTABLE = SHOULD_DELIVER_KEYDOWN |
+                                         SHOULD_DELIVER_KEYPRESS |
+                                         SHOULD_DELIVER_KEYUP;
+const SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE =
+  kStrictKeyPressEvents ? (SHOULD_DELIVER_KEYDOWN | SHOULD_DELIVER_KEYUP) : SHOULD_DELIVER_ALL_FOR_PRINTABLE;
 
 const TEST_PATH = "http://example.net/browser/browser/" +
                   "components/resistfingerprinting/test/browser/";
 
 // The test cases for english content.
 const TEST_CASES_EN = [
-  { key: "KEY_ArrowDown", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_ArrowDown", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "ArrowDown", code: "ArrowDown", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_DOWN,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_ArrowLeft", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_ArrowLeft", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "ArrowLeft", code: "ArrowLeft", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_LEFT,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_ArrowRight", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_ArrowRight", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "ArrowRight", code: "ArrowRight", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_RIGHT,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_ArrowUp", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_ArrowUp", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "ArrowUp", code: "ArrowUp", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_UP,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
   { key: "KEY_CapsLock", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_KEYDOWN,
     result: { key: "CapsLock", code: "CapsLock", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_CAPS_LOCK,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_End", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_End", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "End", code: "End", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_END,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_Enter", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_Enter", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "Enter", code: "Enter", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_RETURN,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_Escape", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_Escape", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "Escape", code: "Escape", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_ESCAPE,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_Home", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_Home", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "Home", code: "Home", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_HOME,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
   { key: "KEY_Meta", modifiers: { location: KeyboardEvent.DOM_KEY_LOCATION_LEFT, metaKey: true },
     expectedKeyEvent: SHOULD_DELIVER_KEYDOWN,
     result: { key: "Meta", code: "OSLeft", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_WIN,
               location: KeyboardEvent.DOM_KEY_LOCATION_LEFT, altKey: false, shiftKey: false,
@@ -82,542 +87,542 @@ const TEST_CASES_EN = [
               ctrlKey: false, altGraphKey: false }
   },
   { key: "KEY_OS", modifiers: { location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT, osKey: true },
     expectedKeyEvent: SHOULD_DELIVER_KEYDOWN,
     result: { key: "OS", code: "OSRight", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_WIN,
               location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_PageDown", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_PageDown", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "PageDown", code: "PageDown", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_PAGE_DOWN,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_PageUp", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_PageUp", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "PageUp", code: "PageUp", charCode: 0, keyCode: nsIDOMKeyEvent.DOM_VK_PAGE_UP,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: " ", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: " ", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: " ", code: "Space", charCode: 32, keyCode: nsIDOMKeyEvent.DOM_VK_SPACE,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ",", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ",", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ",", code: "Comma", charCode: 44, keyCode: nsIDOMKeyEvent.DOM_VK_COMMA,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "<", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "<", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "<", code: "Comma", charCode: 60, keyCode: nsIDOMKeyEvent.DOM_VK_COMMA,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "[", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "[", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "[", code: "BracketLeft", charCode: 91, keyCode: nsIDOMKeyEvent.DOM_VK_OPEN_BRACKET,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "{", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "{", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "{", code: "BracketLeft", charCode: 123, keyCode: nsIDOMKeyEvent.DOM_VK_OPEN_BRACKET,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "]", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "]", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "]", code: "BracketRight", charCode: 93, keyCode: nsIDOMKeyEvent.DOM_VK_CLOSE_BRACKET,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "}", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "}", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "}", code: "BracketRight", charCode: 125, keyCode: nsIDOMKeyEvent.DOM_VK_CLOSE_BRACKET,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "\\", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "\\", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "\\", code: "Backslash", charCode: 92, keyCode: nsIDOMKeyEvent.DOM_VK_BACK_SLASH,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "|", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "|", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "|", code: "Backslash", charCode: 124, keyCode: nsIDOMKeyEvent.DOM_VK_BACK_SLASH,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ";", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ";", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ";", code: "Semicolon", charCode: 59, keyCode: nsIDOMKeyEvent.DOM_VK_SEMICOLON,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ":", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ":", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ":", code: "Semicolon", charCode: 58, keyCode: nsIDOMKeyEvent.DOM_VK_SEMICOLON,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ".", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ".", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ".", code: "Period", charCode: 46, keyCode: nsIDOMKeyEvent.DOM_VK_PERIOD,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ">", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ">", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ">", code: "Period", charCode: 62, keyCode: nsIDOMKeyEvent.DOM_VK_PERIOD,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "/", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "/", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "/", code: "Slash", charCode: 47, keyCode: nsIDOMKeyEvent.DOM_VK_SLASH,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "?", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "?", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "?", code: "Slash", charCode: 63, keyCode: nsIDOMKeyEvent.DOM_VK_SLASH,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "'", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "'", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "'", code: "Quote", charCode: 39, keyCode: nsIDOMKeyEvent.DOM_VK_QUOTE,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "\"", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "\"", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "\"", code: "Quote", charCode: 34, keyCode: nsIDOMKeyEvent.DOM_VK_QUOTE,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "-", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "-", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "-", code: "Minus", charCode: 45, keyCode: nsIDOMKeyEvent.DOM_VK_HYPHEN_MINUS,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "_", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "_", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "_", code: "Minus", charCode: 95, keyCode: nsIDOMKeyEvent.DOM_VK_HYPHEN_MINUS,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "=", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "=", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "=", code: "Equal", charCode: 61, keyCode: nsIDOMKeyEvent.DOM_VK_EQUALS,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "+", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "+", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "+", code: "Equal", charCode: 43, keyCode: nsIDOMKeyEvent.DOM_VK_EQUALS,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "a", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "a", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "a", code: "KeyA", charCode: 97, keyCode: nsIDOMKeyEvent.DOM_VK_A,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "A", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "A", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "A", code: "KeyA", charCode: 65, keyCode: nsIDOMKeyEvent.DOM_VK_A,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "b", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "b", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "b", code: "KeyB", charCode: 98, keyCode: nsIDOMKeyEvent.DOM_VK_B,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "B", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "B", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "B", code: "KeyB", charCode: 66, keyCode: nsIDOMKeyEvent.DOM_VK_B,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "c", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "c", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "c", code: "KeyC", charCode: 99, keyCode: nsIDOMKeyEvent.DOM_VK_C,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "C", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "C", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "C", code: "KeyC", charCode: 67, keyCode: nsIDOMKeyEvent.DOM_VK_C,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "d", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "d", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "d", code: "KeyD", charCode: 100, keyCode: nsIDOMKeyEvent.DOM_VK_D,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "D", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "D", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "D", code: "KeyD", charCode: 68, keyCode: nsIDOMKeyEvent.DOM_VK_D,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "e", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "e", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "e", code: "KeyE", charCode: 101, keyCode: nsIDOMKeyEvent.DOM_VK_E,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "E", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "E", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "E", code: "KeyE", charCode: 69, keyCode: nsIDOMKeyEvent.DOM_VK_E,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "f", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "f", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "f", code: "KeyF", charCode: 102, keyCode: nsIDOMKeyEvent.DOM_VK_F,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "F", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "F", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "F", code: "KeyF", charCode: 70, keyCode: nsIDOMKeyEvent.DOM_VK_F,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "g", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "g", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "g", code: "KeyG", charCode: 103, keyCode: nsIDOMKeyEvent.DOM_VK_G,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "G", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "G", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "G", code: "KeyG", charCode: 71, keyCode: nsIDOMKeyEvent.DOM_VK_G,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "h", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "h", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "h", code: "KeyH", charCode: 104, keyCode: nsIDOMKeyEvent.DOM_VK_H,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "H", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "H", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "H", code: "KeyH", charCode: 72, keyCode: nsIDOMKeyEvent.DOM_VK_H,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "i", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "i", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "i", code: "KeyI", charCode: 105, keyCode: nsIDOMKeyEvent.DOM_VK_I,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "I", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "I", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "I", code: "KeyI", charCode: 73, keyCode: nsIDOMKeyEvent.DOM_VK_I,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "j", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "j", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "j", code: "KeyJ", charCode: 106, keyCode: nsIDOMKeyEvent.DOM_VK_J,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "J", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "J", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "J", code: "KeyJ", charCode: 74, keyCode: nsIDOMKeyEvent.DOM_VK_J,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "k", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "k", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "k", code: "KeyK", charCode: 107, keyCode: nsIDOMKeyEvent.DOM_VK_K,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "K", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "K", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "K", code: "KeyK", charCode: 75, keyCode: nsIDOMKeyEvent.DOM_VK_K,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "l", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "l", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "l", code: "KeyL", charCode: 108, keyCode: nsIDOMKeyEvent.DOM_VK_L,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "L", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "L", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "L", code: "KeyL", charCode: 76, keyCode: nsIDOMKeyEvent.DOM_VK_L,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "m", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "m", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "m", code: "KeyM", charCode: 109, keyCode: nsIDOMKeyEvent.DOM_VK_M,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "M", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "M", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "M", code: "KeyM", charCode: 77, keyCode: nsIDOMKeyEvent.DOM_VK_M,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "n", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "n", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "n", code: "KeyN", charCode: 110, keyCode: nsIDOMKeyEvent.DOM_VK_N,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "N", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "N", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "N", code: "KeyN", charCode: 78, keyCode: nsIDOMKeyEvent.DOM_VK_N,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "o", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "o", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "o", code: "KeyO", charCode: 111, keyCode: nsIDOMKeyEvent.DOM_VK_O,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "O", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "O", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "O", code: "KeyO", charCode: 79, keyCode: nsIDOMKeyEvent.DOM_VK_O,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "p", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "p", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "p", code: "KeyP", charCode: 112, keyCode: nsIDOMKeyEvent.DOM_VK_P,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "P", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "P", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "P", code: "KeyP", charCode: 80, keyCode: nsIDOMKeyEvent.DOM_VK_P,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "q", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "q", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "q", code: "KeyQ", charCode: 113, keyCode: nsIDOMKeyEvent.DOM_VK_Q,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "Q", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "Q", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "Q", code: "KeyQ", charCode: 81, keyCode: nsIDOMKeyEvent.DOM_VK_Q,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "r", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "r", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "r", code: "KeyR", charCode: 114, keyCode: nsIDOMKeyEvent.DOM_VK_R,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "R", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "R", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "R", code: "KeyR", charCode: 82, keyCode: nsIDOMKeyEvent.DOM_VK_R,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "s", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "s", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "s", code: "KeyS", charCode: 115, keyCode: nsIDOMKeyEvent.DOM_VK_S,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "S", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "S", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "S", code: "KeyS", charCode: 83, keyCode: nsIDOMKeyEvent.DOM_VK_S,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "t", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "t", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "t", code: "KeyT", charCode: 116, keyCode: nsIDOMKeyEvent.DOM_VK_T,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "T", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "T", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "T", code: "KeyT", charCode: 84, keyCode: nsIDOMKeyEvent.DOM_VK_T,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "u", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "u", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "u", code: "KeyU", charCode: 117, keyCode: nsIDOMKeyEvent.DOM_VK_U,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "U", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "U", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "U", code: "KeyU", charCode: 85, keyCode: nsIDOMKeyEvent.DOM_VK_U,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "v", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "v", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "v", code: "KeyV", charCode: 118, keyCode: nsIDOMKeyEvent.DOM_VK_V,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "V", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "V", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "V", code: "KeyV", charCode: 86, keyCode: nsIDOMKeyEvent.DOM_VK_V,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "w", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "w", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "w", code: "KeyW", charCode: 119, keyCode: nsIDOMKeyEvent.DOM_VK_W,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "W", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "W", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "W", code: "KeyW", charCode: 87, keyCode: nsIDOMKeyEvent.DOM_VK_W,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "x", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "x", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "x", code: "KeyX", charCode: 120, keyCode: nsIDOMKeyEvent.DOM_VK_X,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "X", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "X", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "X", code: "KeyX", charCode: 88, keyCode: nsIDOMKeyEvent.DOM_VK_X,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "y", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "y", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "y", code: "KeyY", charCode: 121, keyCode: nsIDOMKeyEvent.DOM_VK_Y,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "Y", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "Y", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "Y", code: "KeyY", charCode: 89, keyCode: nsIDOMKeyEvent.DOM_VK_Y,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "z", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "z", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "z", code: "KeyZ", charCode: 122, keyCode: nsIDOMKeyEvent.DOM_VK_Z,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "Z", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "Z", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "Z", code: "KeyZ", charCode: 90, keyCode: nsIDOMKeyEvent.DOM_VK_Z,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "0", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "0", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "0", code: "Digit0", charCode: 48, keyCode: nsIDOMKeyEvent.DOM_VK_0,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "1", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "1", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "1", code: "Digit1", charCode: 49, keyCode: nsIDOMKeyEvent.DOM_VK_1,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "2", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "2", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "2", code: "Digit2", charCode: 50, keyCode: nsIDOMKeyEvent.DOM_VK_2,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "3", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "3", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "3", code: "Digit3", charCode: 51, keyCode: nsIDOMKeyEvent.DOM_VK_3,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "4", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "4", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "4", code: "Digit4", charCode: 52, keyCode: nsIDOMKeyEvent.DOM_VK_4,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "5", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "5", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "5", code: "Digit5", charCode: 53, keyCode: nsIDOMKeyEvent.DOM_VK_5,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "6", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "6", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "6", code: "Digit6", charCode: 54, keyCode: nsIDOMKeyEvent.DOM_VK_6,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "7", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "7", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "7", code: "Digit7", charCode: 55, keyCode: nsIDOMKeyEvent.DOM_VK_7,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "8", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "8", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "8", code: "Digit8", charCode: 56, keyCode: nsIDOMKeyEvent.DOM_VK_8,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "9", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "9", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "9", code: "Digit9", charCode: 57, keyCode: nsIDOMKeyEvent.DOM_VK_9,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: ")", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: ")", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: ")", code: "Digit0", charCode: 41, keyCode: nsIDOMKeyEvent.DOM_VK_0,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "!", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "!", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "!", code: "Digit1", charCode: 33, keyCode: nsIDOMKeyEvent.DOM_VK_1,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "@", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "@", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "@", code: "Digit2", charCode: 64, keyCode: nsIDOMKeyEvent.DOM_VK_2,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "#", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "#", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "#", code: "Digit3", charCode: 35, keyCode: nsIDOMKeyEvent.DOM_VK_3,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "$", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "$", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "$", code: "Digit4", charCode: 36, keyCode: nsIDOMKeyEvent.DOM_VK_4,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "%", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "%", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "%", code: "Digit5", charCode: 37, keyCode: nsIDOMKeyEvent.DOM_VK_5,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "^", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "^", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "^", code: "Digit6", charCode: 94, keyCode: nsIDOMKeyEvent.DOM_VK_6,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "&", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "&", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "&", code: "Digit7", charCode: 38, keyCode: nsIDOMKeyEvent.DOM_VK_7,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "*", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "*", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "*", code: "Digit8", charCode: 42, keyCode: nsIDOMKeyEvent.DOM_VK_8,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "(", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "(", modifiers: { shiftKey: true }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
     result: { key: "(", code: "Digit9", charCode: 40, keyCode: nsIDOMKeyEvent.DOM_VK_9,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: true,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F1", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F1", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F1", code: "F1", charCode: 112, keyCode: nsIDOMKeyEvent.DOM_VK_F1,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F2", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F2", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F2", code: "F2", charCode: 113, keyCode: nsIDOMKeyEvent.DOM_VK_F2,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F3", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F3", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F3", code: "F3", charCode: 114, keyCode: nsIDOMKeyEvent.DOM_VK_F3,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F4", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F4", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F4", code: "F4", charCode: 115, keyCode: nsIDOMKeyEvent.DOM_VK_F4,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F5", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F5", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F5", code: "F5", charCode: 116, keyCode: nsIDOMKeyEvent.DOM_VK_F5,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F7", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F7", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F7", code: "F7", charCode: 118, keyCode: nsIDOMKeyEvent.DOM_VK_F7,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F8", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F8", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F8", code: "F8", charCode: 119, keyCode: nsIDOMKeyEvent.DOM_VK_F8,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F9", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F9", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F9", code: "F9", charCode: 120, keyCode: nsIDOMKeyEvent.DOM_VK_F9,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F10", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F10", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F10", code: "F10", charCode: 121, keyCode: nsIDOMKeyEvent.DOM_VK_F10,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F11", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F11", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F11", code: "F11", charCode: 122, keyCode: nsIDOMKeyEvent.DOM_VK_F11,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
-  { key: "KEY_F12", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL,
+  { key: "KEY_F12", modifiers: {}, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_NON_PRINTABLE,
     result: { key: "F12", code: "F12", charCode: 123, keyCode: nsIDOMKeyEvent.DOM_VK_F12,
               location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
               ctrlKey: false, altGraphKey: false }
   },
 ];
 
 async function testKeyEvent(aTab, aTestCase) {
   // Prepare all expected key events.
@@ -731,17 +736,17 @@ add_task(async function runTestsForEngli
 
   for (let test of TEST_CASES_EN) {
     await testKeyEvent(tab, test);
   }
 
   // Test a key which doesn't exist in US English keyboard layout.
   await testKeyEvent(tab,
     {
-      key: "\u00DF", modifiers: { code: "Minus", keyCode: 63 }, expectedKeyEvent: SHOULD_DELIVER_ALL,
+      key: "\u00DF", modifiers: { code: "Minus", keyCode: 63 }, expectedKeyEvent: SHOULD_DELIVER_ALL_FOR_PRINTABLE,
       result: { key: "\u00DF", code: "", charCode: 223, keyCode: 0,
                 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD, altKey: false, shiftKey: false,
                 ctrlKey: false, altGraphKey: false }
     }
   );
 
   gBrowser.removeEventListener("keypress", eventConsumer, true);
 
--- a/devtools/client/shared/test/browser_treeWidget_keyboard_interaction.js
+++ b/devtools/client/shared/test/browser_treeWidget_keyboard_interaction.js
@@ -6,16 +6,19 @@
 
 // Tests that keyboard interaction works fine with the tree widget
 
 const TEST_URI = "data:text/html;charset=utf-8,<head>" +
   "<link rel='stylesheet' type='text/css' href='chrome://devtools/skin/widg" +
   "ets.css'></head><body><div></div><span></span></body>";
 const {TreeWidget} = require("devtools/client/shared/widgets/TreeWidget");
 
+const kStrictKeyPressEvents = SpecialPowers.getBoolPref(
+  "dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 add_task(async function () {
   await addTab("about:blank");
   let [host, win, doc] = await createHost("bottom", TEST_URI);
 
   let tree = new TreeWidget(doc.querySelector("div"), {
     defaultType: "store"
   });
 
@@ -100,128 +103,129 @@ async function testKeyboardInteraction(t
   node = tree.root.children.firstChild.nextSibling.firstChild;
   // node should not have selected class
   ok(!node.classList.contains("theme-selected"), "Node should not have selected class");
   ok(!node.hasAttribute("expanded"), "Node is not expanded");
 
   info("Pressing down key to select next item");
   event = defer();
   tree.once("select", pass);
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   let [name, data, attachment] = await event.promise;
   is(name, "select", "Select event was fired after pressing down");
   is(data[0], "level1", "Correct item was selected after pressing down");
   ok(!attachment, "null attachment was emitted");
   ok(node.classList.contains("theme-selected"), "Node has selected class");
   ok(node.hasAttribute("expanded"), "Node is expanded now");
 
   info("Pressing down key again to select next item");
   event = defer();
   tree.once("select", pass);
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   [name, data, attachment] = await event.promise;
   is(data.length, 2, "Correct level item was selected after second down keypress");
   is(data[0], "level1", "Correct parent level");
   is(data[1], "level2", "Correct second level");
 
   info("Pressing down key again to select next item");
   event = defer();
   tree.once("select", pass);
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   [name, data, attachment] = await event.promise;
   is(data.length, 3, "Correct level item was selected after third down keypress");
   is(data[0], "level1", "Correct parent level");
   is(data[1], "level2", "Correct second level");
   is(data[2], "level3", "Correct third level");
 
   info("Pressing down key again to select next item");
   event = defer();
   tree.once("select", pass);
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   [name, data, attachment] = await event.promise;
   is(data.length, 2, "Correct level item was selected after fourth down keypress");
   is(data[0], "level1", "Correct parent level");
   is(data[1], "level2-1", "Correct second level");
 
   // pressing left to check expand collapse feature.
   // This does not emit any event, so listening for keypress
-  tree.root.children.addEventListener("keypress", function () {
+  const eventToListen = kStrictKeyPressEvents ? "keydown" : "keypress";
+  tree.root.children.addEventListener(eventToListen, () => {
     // executeSoon so that other listeners on the same method are executed first
     executeSoon(() => event.resolve(null));
   }, {once: true});
   info("Pressing left key to collapse the item");
   event = defer();
   node = tree._selectedLabel;
   ok(node.hasAttribute("expanded"), "Item is expanded before left keypress");
-  EventUtils.sendKey("LEFT", win);
+  EventUtils.synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"}, win);
   await event.promise;
 
   ok(!node.hasAttribute("expanded"), "Item is not expanded after left keypress");
 
   // pressing left on collapsed item should select the previous item
 
   info("Pressing left key on collapsed item to select previous");
   tree.once("select", pass);
   event = defer();
   // parent node should have no effect of this keypress
   node = tree.root.children.firstChild.nextSibling.firstChild;
   ok(node.hasAttribute("expanded"), "Parent is expanded");
-  EventUtils.sendKey("LEFT", win);
+  EventUtils.synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"}, win);
   [name, data] = await event.promise;
   is(data.length, 3, "Correct level item was selected after second left keypress");
   is(data[0], "level1", "Correct parent level");
   is(data[1], "level2", "Correct second level");
   is(data[2], "level3", "Correct third level");
   ok(node.hasAttribute("expanded"), "Parent is still expanded after left keypress");
 
   // pressing down again
 
   info("Pressing down key to select next item");
   event = defer();
   tree.once("select", pass);
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   [name, data, attachment] = await event.promise;
   is(data.length, 2, "Correct level item was selected after fifth down keypress");
   is(data[0], "level1", "Correct parent level");
   is(data[1], "level2-1", "Correct second level");
 
   // collapsing the item to check expand feature.
 
-  tree.root.children.addEventListener("keypress", function () {
+  tree.root.children.addEventListener(eventToListen, () => {
     executeSoon(() => event.resolve(null));
   }, {once: true});
   info("Pressing left key to collapse the item");
   event = defer();
   node = tree._selectedLabel;
   ok(node.hasAttribute("expanded"), "Item is expanded before left keypress");
-  EventUtils.sendKey("LEFT", win);
+  EventUtils.synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"}, win);
   await event.promise;
   ok(!node.hasAttribute("expanded"), "Item is collapsed after left keypress");
 
   // pressing right should expand this now.
 
-  tree.root.children.addEventListener("keypress", function () {
+  tree.root.children.addEventListener(eventToListen, () => {
     executeSoon(() => event.resolve(null));
   }, {once: true});
   info("Pressing right key to expend the collapsed item");
   event = defer();
   node = tree._selectedLabel;
   ok(!node.hasAttribute("expanded"), "Item is collapsed before right keypress");
-  EventUtils.sendKey("RIGHT", win);
+  EventUtils.synthesizeKey("KEY_ArrowRight", {code: "ArrowRight"}, win);
   await event.promise;
   ok(node.hasAttribute("expanded"), "Item is expanded after right keypress");
 
   // selecting last item node to test edge navigation case
 
   tree.selectedItem = ["level1.1", "level2", "level3"];
   node = tree._selectedLabel;
   // pressing down again should not change selection
   event = defer();
-  tree.root.children.addEventListener("keypress", function () {
+  tree.root.children.addEventListener(eventToListen, () => {
     executeSoon(() => event.resolve(null));
   }, {once: true});
   info("Pressing down key on last item of the tree");
-  EventUtils.sendKey("DOWN", win);
+  EventUtils.synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"}, win);
   await event.promise;
 
   ok(tree.isSelected(["level1.1", "level2", "level3"]),
      "Last item is still selected after pressing down on last item of the tree");
 }
--- a/dom/events/test/test_dom_keyboard_event.html
+++ b/dom/events/test/test_dom_keyboard_event.html
@@ -12,16 +12,19 @@
   
 </div>
 <pre id="test">
 <script type="application/javascript">
 
 SimpleTest.waitForExplicitFinish();
 SimpleTest.waitForFocus(runTests, window);
 
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 function testInitializingUntrustedEvent()
 {
   const kTests = [
     // initKeyEvent
     { createEventArg: "KeyboardEvent", useInitKeyboardEvent: false,
       type: "keydown", bubbles: true, cancelable: true, view: null,
       ctrlKey: false, altKey: false, shiftKey: false, metaKey: false,
       keyCode: 0x00, charCode: 0x00, detail: 0, key: "", location: 0,
@@ -202,96 +205,116 @@ function testInitializingUntrustedEvent(
          description + "getModifierState(\"" + kInvalidModifierName[k] + "\") returns wrong value");
     }
   }
 }
 
 function testSynthesizedKeyLocation()
 {
   const kTests = [
-    { key: "a", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "a", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_A,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_SHIFT", isModifier: true,
-      event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Shift", isModifier: true, isPrintable: false,
+      event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_SHIFT,
                location: KeyboardEvent.DOM_KEY_LOCATION_LEFT },
     },
-    { key: "VK_SHIFT", isModifier: true,
-      event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Shift", isModifier: true, isPrintable: false,
+      event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_SHIFT,
                location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT },
     },
-    { key: "VK_CONTROL", isModifier: true,
-      event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false,
+    { key: "KEY_Control", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_CONTROL,
                location: KeyboardEvent.DOM_KEY_LOCATION_LEFT },
     },
-    { key: "VK_CONTROL", isModifier: true,
-      event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false,
+    { key: "KEY_Control", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_CONTROL,
                location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT },
     },
 /* XXX Alt key activates menubar even if we consume the key events.
-    { key: "VK_ALT", isModifier: true,
-      event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false,
+    { key: "KEY_Alt", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_ALT,
                location: KeyboardEvent.DOM_KEY_LOCATION_LEFT },
     },
-    { key: "VK_ALT", isModifier: true,
-      event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false,
+    { key: "KEY_Alt", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_ALT,
                location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT },
     },
 */
-    { key: "VK_META", isModifier: true,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true,
+    { key: "KEY_Meta", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_META,
                location: KeyboardEvent.DOM_KEY_LOCATION_LEFT },
     },
-    { key: "VK_META", isModifier: true,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true,
+    { key: "KEY_Meta", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_META,
                location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT },
     },
-    { key: "VK_DOWN", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_ArrowDown", isModifier: false, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_DOWN,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_DOWN", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_ArrowDown", isModifier: false, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_DOWN,
                location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD },
     },
-    { key: "5", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "5", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_5,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_NUMPAD5", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "5", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,  numLockKey: true,
+               keyCode: KeyboardEvent.DOM_VK_NUMPAD5,
                location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD },
     },
-    { key: "+", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "+", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_EQUALS,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_ADD", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "+", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: true,
+               keyCode: KeyboardEvent.DOM_VK_ADD,
                location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD },
     },
-    { key: "VK_RETURN", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Enter", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_RETURN,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_RETURN", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Enter", isModifier: false, isPrintable: true,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_RETURN,
                location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD },
     },
-    { key: "VK_NUM_LOCK", isModifier: true,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_NumLock", isModifier: true, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_NUM_LOCK,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_INSERT", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Insert", isModifier: false, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_INSERT,
                location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD },
     },
-    { key: "VK_INSERT", isModifier: false,
-      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false,
+    { key: "KEY_Insert", isModifier: false, isPrintable: false,
+      event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false,
+               keyCode: KeyboardEvent.DOM_VK_INSERT,
                location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD },
     },
   ];
 
   function getLocationName(aLocation)
   {
     switch (aLocation) {
       case KeyboardEvent.DOM_KEY_LOCATION_STANDARD:
@@ -328,20 +351,28 @@ function testSynthesizedKeyLocation()
   for (var i = 0; i < kTests.length; i++) {
     currentTest = kTests[i];
     events = { keydown: false, keypress: false, keyup: false };
     description = "testSynthesizedKeyLocation, " + i + ", key: " +
       currentTest.key + ", location: " +
       getLocationName(currentTest.event.location) + ": ";
     synthesizeKey(currentTest.key, currentTest.event);
     ok(events.keydown, description + "keydown event wasn't fired");
-    if (currentTest.isModifier) {
-      todo(events.keypress, description + "keypress event was fired for modifier key");
+    if (kStrictKeyPressEvents) {
+      if (currentTest.isPrintable) {
+        ok(events.keypress, description + "keypress event wasn't fired for printable key");
+      } else {
+        ok(!events.keypress, description + "keypress event was fired for non-printable key");
+      }
     } else {
-      ok(events.keypress, description + "keypress event wasn't fired");
+      if (currentTest.isModifier) {
+        todo(events.keypress, description + "keypress event was fired for modifier key");
+      } else {
+        ok(events.keypress, description + "keypress event wasn't fired");
+      }
     }
     ok(events.keyup, description + "keyup event wasn't fired");
   }
 
   window.removeEventListener("keydown", handler, true);
   window.removeEventListener("keypress", handler, true);
   window.removeEventListener("keyup", handler, true);
 }
--- a/dom/html/test/browser_fullscreen-api-keys.js
+++ b/dom/html/test/browser_fullscreen-api-keys.js
@@ -3,16 +3,19 @@
 /** Test for Bug 545812 **/
 
 // List of key codes which should exit full-screen mode.
 const kKeyList = [
   { code: "VK_ESCAPE", suppressed: true},
   { code: "VK_F11",    suppressed: false},
 ];
 
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 function frameScript() {
   let doc = content.document;
   addMessageListener("Test:RequestFullscreen", () => {
     doc.body.requestFullscreen();
   });
   addMessageListener("Test:DispatchUntrustedKeyEvents", msg => {
     var evt = new content.CustomEvent("Test:DispatchKeyEvents", {
       detail: { code: msg.data }
@@ -77,24 +80,24 @@ function captureUnexpectedKeyEvent(type)
 async function temporaryRemoveUnexpectedKeyEventCapture(callback) {
   gMessageManager.removeMessageListener(
     "Test:KeyReceived", captureUnexpectedKeyEvent);
   await callback();
   gMessageManager.addMessageListener(
     "Test:KeyReceived", captureUnexpectedKeyEvent);
 }
 
-function receiveExpectedKeyEvents(keyCode) {
+function receiveExpectedKeyEvents(aKeyCode, aTrusted) {
   return new Promise(resolve => {
-    let events = ["keydown", "keypress", "keyup"];
+    let events = kStrictKeyPressEvents && aTrusted ? ["keydown", "keyup"] : ["keydown", "keypress", "keyup"];
     function listener({ data }) {
       let expected = events.shift();
       is(data.type, expected, `Should receive a ${expected} event`);
-      is(data.keyCode, keyCode,
-         `Should receive the event with key code ${keyCode}`);
+      is(data.keyCode, aKeyCode,
+         `Should receive the event with key code ${aKeyCode}`);
       if (!events.length) {
         gMessageManager.removeMessageListener("Test:KeyReceived", listener);
         resolve();
       }
     }
     gMessageManager.addMessageListener("Test:KeyReceived", listener);
   });
 }
@@ -143,26 +146,26 @@ add_task(async function() {
       let state = await promiseOneMessage("Test:FullscreenChanged");
       ok(state, "The content should have entered fullscreen");
       ok(document.fullscreenElement,
          "The chrome should also be in fullscreen");
     });
 
     info("Dispatch untrusted key events from content");
     await temporaryRemoveUnexpectedKeyEventCapture(async function() {
-      let promiseExpectedKeyEvents = receiveExpectedKeyEvents(keyCode);
+      let promiseExpectedKeyEvents = receiveExpectedKeyEvents(keyCode, false);
       gMessageManager.sendAsyncMessage("Test:DispatchUntrustedKeyEvents", code);
       await promiseExpectedKeyEvents;
     });
 
     info("Send trusted key events");
     await temporaryRemoveUnexpectedFullscreenChangeCapture(async function() {
       await temporaryRemoveUnexpectedKeyEventCapture(async function() {
         let promiseExpectedKeyEvents = suppressed ?
-          Promise.resolve() : receiveExpectedKeyEvents(keyCode);
+          Promise.resolve() : receiveExpectedKeyEvents(keyCode, true);
         EventUtils.synthesizeKey(code, {});
         await promiseExpectedKeyEvents;
         let state = await promiseOneMessage("Test:FullscreenChanged");
         ok(!state, "The content should have exited fullscreen");
         ok(!document.fullscreenElement,
            "The chrome should also have exited fullscreen");
       });
     });
--- a/dom/html/test/forms/test_input_number_key_events.html
+++ b/dom/html/test/forms/test_input_number_key_events.html
@@ -30,16 +30,18 @@ SimpleTest.waitForFocus(function() {
   SpecialPowers.pushPrefEnv({"set":[["snav.enabled", false]]}, function() {
     test();
     SimpleTest.finish();
   });
 });
 const defaultMinimum = "NaN";
 const defaultMaximum = "NaN";
 const defaultStep = 1;
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
 
 // Helpers:
 // For the sake of simplicity, we do not currently support fractional value,
 // step, etc.
 
 function getMinimum(element) {
   return Number(element.min || defaultMinimum);
 }
@@ -136,30 +138,30 @@ function expectedValueAfterStepUpOrDown(
   } else if (stepFactor > 0 && !isNaN(maximum)) {
     value = Math.min(value, maximum);
   }
 
   return value;
 }
 
 function expectedValAfterKeyEvent(key, element) {
-  return expectedValueAfterStepUpOrDown(key == "VK_UP" ? 1 : -1, element);
+  return expectedValueAfterStepUpOrDown(key == "KEY_ArrowUp" ? 1 : -1, element);
 }
 
 function test() {
   var elem = document.getElementById("input");
   elem.focus();
 
   elem.min = -5;
   elem.max = 5;
   elem.step = 2;
   var defaultValue = 0;
   var oldVal, expectedVal;
 
-  for (key of ["VK_UP", "VK_DOWN"]) {
+  for (key of ["KEY_ArrowUp", "KEY_ArrowDown"]) {
     // Start at middle:
     oldVal = elem.value = -1;
     expectedVal = expectedValAfterKeyEvent(key, elem);
     synthesizeKey(key, {});
     is(elem.value, String(expectedVal), "Test " + key + " for number control with value set between min/max (" + oldVal + ")");
 
     // Same again:
     expectedVal = expectedValAfterKeyEvent(key, elem);
@@ -184,20 +186,19 @@ function test() {
     is(elem.value, String(expectedVal), "Test " + key + " for number control with value set to the minimum (" + oldVal + ")");
 
     // Same again:
     expectedVal = expectedValAfterKeyEvent(key, elem);
     synthesizeKey(key, {});
     is(elem.value, String(expectedVal), "Test repeat of " + key + " for number control");
 
     // Test preventDefault():
-    elem.addEventListener("keypress", function(evt) {
+    elem.addEventListener(kStrictKeyPressEvents ? "keydown" : "keypress", function(evt) {
       evt.preventDefault();
-      elem.removeEventListener("keypress", arguments.callee);
-    });
+    }, {once: true});
     oldVal = elem.value = 0;
     expectedVal = 0;
     synthesizeKey(key, {});
     is(elem.value, String(expectedVal), "Test " + key + " for number control where scripted preventDefault() should prevent the value changing");
 
     // Test step="any" behavior:
     var oldStep = elem.step;
     elem.step = "any";
--- a/dom/html/test/test_bug1295719_event_sequence_for_arrow_keys.html
+++ b/dom/html/test/test_bug1295719_event_sequence_for_arrow_keys.html
@@ -18,50 +18,55 @@ https://bugzilla.mozilla.org/show_bug.cg
 <input id="test_number" type="number" value=50>
 <input id="test_range" type="range" value=50 max=100 min=0>
 <script type="text/javascript">
 
 /** Test for Bug 1295719 **/
 SimpleTest.waitForExplicitFinish();
 SimpleTest.waitForFocus(runTests);
 
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 function runTests() {
   let number = window.document.getElementById("test_number");
   let range = window.document.getElementById("test_range");
-  let waiting_event_sequence = ["keydown", "keypress", "input", "change"];
+  let waiting_event_sequence =
+    kStrictKeyPressEvents ? ["keydown", "input", "change"] :
+                            ["keydown", "keypress", "input", "change"];
 
   let waiting_event_idx = 0;
   waiting_event_sequence.forEach((eventType) => {
     number.addEventListener(eventType, (event) => {
       let waiting_event = waiting_event_sequence[waiting_event_idx];
       is(waiting_event, eventType, "Waiting " + waiting_event + " get " + eventType);
       // Input element will fire input and change events when handling keypress
       // with keycode=arrows. When user press and hold the keyboard, we expect
-      // that input element repeatedly fires "keydown", "keypress", "input", and
+      // that input element repeatedly fires "keydown"(, "keypress"), "input", and
       // "change" events until user release the keyboard. Using
       // waiting_event_sequence as a circular buffer and reset waiting_event_idx
       // when it point to the end of buffer.
       waiting_event_idx = waiting_event_idx == waiting_event_sequence.length -1 ? 0 : waiting_event_idx + 1;
     });
     range.addEventListener(eventType, (event) => {
       let waiting_event = waiting_event_sequence[waiting_event_idx];
       is(waiting_event, eventType, "Waiting " + waiting_event + " get " + eventType);
       waiting_event_idx = waiting_event_idx == waiting_event_sequence.length - 1 ? 0 : waiting_event_idx + 1;
     });
   });
 
   number.focus();
-  synthesizeKey("VK_DOWN", {type: "keydown"});
-  synthesizeKey("VK_DOWN", {type: "keydown"});
-  synthesizeKey("VK_DOWN", {type: "keyup"});
+  synthesizeKey("KEY_ArrowDown", {type: "keydown", code: "ArrowDown"});
+  synthesizeKey("KEY_ArrowDown", {type: "keydown", code: "ArrowDown"});
+  synthesizeKey("KEY_ArrowDown", {type: "keyup", code: "ArrowDown"});
   number.blur();
   range.focus();
   waiting_event_idx = 0;
-  synthesizeKey("VK_DOWN", {type: "keydown"});
-  synthesizeKey("VK_DOWN", {type: "keydown"});
-  synthesizeKey("VK_DOWN", {type: "keyup"});
+  synthesizeKey("KEY_ArrowDown", {type: "keydown", code: "ArrowDown"});
+  synthesizeKey("KEY_ArrowDown", {type: "keydown", code: "ArrowDown"});
+  synthesizeKey("KEY_ArrowDown", {type: "keyup", code: "ArrowDown"});
 
   SimpleTest.finish();
 }
 
 </script>
 </body>
 </html>
--- a/dom/html/test/test_bug633058.html
+++ b/dom/html/test/test_bug633058.html
@@ -17,50 +17,55 @@ https://bugzilla.mozilla.org/show_bug.cg
 </div>
 <pre id="test">
 <script type="application/javascript">
 
 /** Test for Bug 633058 **/
 
 SimpleTest.waitForExplicitFinish();
 
-// Turn off Spatial Navigation so that the 'keypress' event fires.
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
+// Turn off Spatial Navigation so that the 'keypress' event fires in traditional behavior.
 SimpleTest.waitForFocus(function() {
   SpecialPowers.pushPrefEnv({"set":[['snav.enabled', false]]}, startTest);
 });
 function startTest() {
-  var nbExpectedKeyPress = 8;
+  var nbExpectedKeyDown = 8;
+  var nbExpectedKeyPress = kStrictKeyPressEvents ? 1 : 8;
   var inputGotKeyPress = 0;
+  var inputGotKeyDown = 0;
   var divGotKeyPress = 0;
+  var divGotKeyDown = 0;
 
   var input = document.getElementsByTagName('input')[0];
   var content = document.getElementById('content');
 
-  content.addEventListener('keypress', function() {
-    divGotKeyPress++;
+  content.addEventListener("keydown", () => { divGotKeyDown++; });
+  content.addEventListener("keypress", () => { divGotKeyPress++; });
+  input.addEventListener("keydown", () => { inputGotKeyDown++; });
+  input.addEventListener("keypress", () => { inputGotKeyPress++; });
 
-    if (divGotKeyPress == nbExpectedKeyPress) {
+  input.addEventListener('focus', function() {
+    SimpleTest.executeSoon(() => {
+      synthesizeKey('KEY_ArrowUp', {});
+      synthesizeKey('KEY_ArrowLeft', {});
+      synthesizeKey('KEY_ArrowRight', {});
+      synthesizeKey('KEY_ArrowDown', {});
+      synthesizeKey('KEY_Backspace', {});
+      synthesizeKey('KEY_Delete', {});
+      synthesizeKey('KEY_Escape', {});
+      synthesizeKey('KEY_Enter', {});  // Will dispatch keypress event even in strict behavior.
+
+      is(inputGotKeyDown, nbExpectedKeyDown, "input got all keydown events");
       is(inputGotKeyPress, nbExpectedKeyPress, "input got all keypress events");
+      is(divGotKeyDown, nbExpectedKeyDown, "div got all keydown events");
       is(divGotKeyPress, nbExpectedKeyPress, "div got all keypress events");
       SimpleTest.finish();
-    }
-  });
-
-  input.addEventListener('keypress', function() {
-    inputGotKeyPress++;
-  });
-
-  input.addEventListener('focus', function() {
-    synthesizeKey('VK_UP', {});
-    synthesizeKey('VK_LEFT', {});
-    synthesizeKey('VK_RIGHT', {});
-    synthesizeKey('VK_DOWN', {});
-    synthesizeKey('VK_BACK_SPACE', {});
-    synthesizeKey('VK_DELETE', {});
-    synthesizeKey('VK_ESCAPE', {});
-    synthesizeKey('VK_RETURN', {});
+    });
   }, {once: true});
   input.focus();
 }
 </script>
 </pre>
 </body>
 </html>
--- a/layout/forms/test/test_bug935876.html
+++ b/layout/forms/test/test_bug935876.html
@@ -46,16 +46,19 @@ https://bugzilla.mozilla.org/show_bug.cg
 </pre>
 <script type="application/javascript">
 SimpleTest.waitForExplicitFinish();
 
 const kIsWin = navigator.platform.indexOf("Win") == 0;
 const kIsMac = navigator.platform.indexOf("Mac") == 0;
 const kIsAndroid = navigator.appVersion.indexOf("Android") != 0;
 
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 function runTests()
 {
   var doPreventDefault = false;
   function onKeydown(aEvent)
   {
     if (doPreventDefault) {
       aEvent.preventDefault();
     }
@@ -80,108 +83,116 @@ function runTests()
 
   function reset()
   {
     keyPressEventFired = false;
     keyDownEventConsumedByJS = false;
     keyDownEventConsumed = false;
   }
 
-  function check(aExpectingKeydownConsumed, aDescription)
+  function check(aExpectingKeydownConsumed, aIsPrintableKey, aDescription)
   {
     if (doPreventDefault) {
       ok(!keyPressEventFired, "keypress event shouldn't be fired for " + aDescription +
                               " if preventDefault() of keydown event was called");
       ok(keyDownEventConsumedByJS, "keydown event of " + aDescription +
                                    " should be consumed in content level if preventDefault() of keydown event is called");
       ok(keyDownEventConsumed, "keydown event of " + aDescription +
                                " should be consumed in system level if preventDefault() of keydown event is called");
     } else if (aExpectingKeydownConsumed) {
       ok(!keyPressEventFired, "keypress event shouldn't be fired for " + aDescription);
       ok(!keyDownEventConsumedByJS, "keydown event of " + aDescription + " shouldn't be consumed in content level");
       ok(keyDownEventConsumed, "keydown event of " + aDescription + " should be consumed in system level");
     } else {
-      ok(keyPressEventFired, "keypress event should be fired for " + aDescription);
+      if (aIsPrintableKey) {
+        ok(keyPressEventFired, "keypress event should be fired for printable key, " + aDescription);
+      } else {
+        if (kStrictKeyPressEvents) {
+          ok(!keyPressEventFired, "keypress event shouldn't be fired for non-printable key, " + aDescription);
+        } else {
+          ok(keyPressEventFired, "keypress event should be fired even for non-printable key, " + aDescription);
+        }
+      }
       ok(!keyDownEventConsumedByJS, "keydown event of " + aDescription + " shouldn't be consumed in content level");
       ok(!keyDownEventConsumed, "keydown event of " + aDescription + " should be consumed in system level");
     }
   }
 
   var listbox = document.getElementById("listbox");
   listbox.addEventListener("keydown", onKeydown);
   listbox.addEventListener("keypress", onKeypress);
   SpecialPowers.addSystemEventListener(listbox, "keydown", onkeydownInSystemEventGroup, false);
 
   listbox.focus();
 
   [ false, true ].forEach(function (consume) {
     doPreventDefault = consume;
     for (var i = 0; i < listbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_DOWN", {});
-      check(true, "DownArrow key on listbox #" + i);
+      synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"});
+      check(true, false, "DownArrow key on listbox #" + i);
     }
 
     for (var i = 0; i < listbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_UP", {});
-      check(true, "UpArrow key on listbox #" + i);
+      synthesizeKey("KEY_ArrowUp", {code: "ArrowUp"});
+      check(true, false, "'ArrowUp' key on listbox #" + i);
     }
 
     for (var i = 0; i < listbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_RIGHT", {});
-      check(true, "RightArrow key on listbox #" + i);
+      synthesizeKey("KEY_ArrowRight", {code: "ArrowRight"});
+      check(true, false, "'ArrowRight' key on listbox #" + i);
     }
 
     for (var i = 0; i < listbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_LEFT", {});
-      check(true, "LeftArrow key on listbox #" + i);
+      synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"});
+      check(true, false, "'ArrowLeft' key on listbox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_DOWN", {});
-      check(true, "PageDown key on listbox #" + i);
+      synthesizeKey("KEY_PageDown", {code: "PageDown"});
+      check(true, false, "'PageDown' key on listbox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_UP", {});
-      check(true, "PageUp key on listbox #" + i);
+      synthesizeKey("KEY_PageUp", {code: "PageUp"});
+      check(true, false, "'PageUp' key on listbox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_END", {});
-      check(true, "End key on listbox #" + i);
+      synthesizeKey("KEY_End", {code: "End"});
+      check(true, false, "'End' key on listbox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_HOME", {});
-      check(true, "Home key on listbox #" + i);
+      synthesizeKey("KEY_Home", {code: "Home"});
+      check(true, false, "'Home' key on listbox #" + i);
     }
 
     reset()
-    synthesizeKey("VK_RETURN", {});
-    check(false, "Enter key on listbox");
+    synthesizeKey("KEY_Enter", {code: "Enter"});
+    check(false, true, "'Enter' key on listbox");
 
     reset()
-    synthesizeKey("VK_ESCAPE", {});
-    check(false, "Esc key on listbox");
+    synthesizeKey("KEY_Escape", {code: "Escape"});
+    check(false, false, "'Escape' key on listbox");
 
     reset()
-    synthesizeKey("VK_F4", {});
-    check(false, "F4 key on listbox");
+    synthesizeKey("KEY_F4", {code: "F4"});
+    check(false, false, "F4 key on listbox");
 
     reset()
-    synthesizeKey("a", {});
-    check(false, "'A' key on listbox");
+    synthesizeKey("a", {code: "KeyA"});
+    check(false, true, "'A' key on listbox");
   });
 
   listbox.removeEventListener("keydown", onKeydown);
   listbox.removeEventListener("keypress", onKeypress);
   SpecialPowers.removeSystemEventListener(listbox, "keydown", onkeydownInSystemEventGroup, false);
 
 
 
@@ -191,77 +202,77 @@ function runTests()
   SpecialPowers.addSystemEventListener(multipleListbox, "keydown", onkeydownInSystemEventGroup, false);
 
   multipleListbox.focus();
 
   [ false, true ].forEach(function (consume) {
     doPreventDefault = consume;
     for (var i = 0; i < multipleListbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_DOWN", {});
-      check(true, "DownArrow key on multiple listbox #" + i);
+      synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"});
+      check(true, false, "'ArrowDown' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < multipleListbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_UP", {});
-      check(true, "UpArrow key on multiple listbox #" + i);
+      synthesizeKey("KEY_ArrowUp", {code: "ArrowUp"});
+      check(true, false, "'ArrowUp' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < multipleListbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_RIGHT", {});
-      check(true, "RightArrow key on multiple listbox #" + i);
+      synthesizeKey("KEY_ArrowRight", {code: "ArrowRight"});
+      check(true, false, "'ArrowRight' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < multipleListbox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_LEFT", {});
-      check(true, "LeftArrow key on multiple listbox #" + i);
+      synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"});
+      check(true, false, "'ArrowLeft' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_DOWN", {});
-      check(true, "PageDown key on multiple listbox #" + i);
+      synthesizeKey("KEY_PageDown", {code: "PageDown"});
+      check(true, false, "'PageDown' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_UP", {});
-      check(true, "PageUp key on multiple listbox #" + i);
+      synthesizeKey("KEY_PageUp", {code: "PageUp"});
+      check(true, false, "'PageUp' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_END", {});
-      check(true, "End key on multiple listbox #" + i);
+      synthesizeKey("KEY_End", {code: "End"});
+      check(true, false, "'End' key on multiple listbox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_HOME", {});
-      check(true, "Home key on multiple listbox #" + i);
+      synthesizeKey("KEY_Home", {code: "Home"});
+      check(true, false, "'Home' key on multiple listbox #" + i);
     }
 
     reset()
-    synthesizeKey("VK_RETURN", {});
-    check(true, "Enter key on multiple listbox");
+    synthesizeKey("KEY_Enter", {code: "Enter"});
+    check(true, true, "'Enter' key on multiple listbox");
 
     reset()
-    synthesizeKey("VK_ESCAPE", {});
-    check(false, "Esc key on multiple listbox");
+    synthesizeKey("KEY_Escape", {code: "Escape"});
+    check(false, false, "'Escape' key on multiple listbox");
 
     reset()
-    synthesizeKey("VK_F4", {});
-    check(false, "F4 key on multiple listbox");
+    synthesizeKey("KEY_F4", {code: "F4"});
+    check(false, false, "'F4' key on multiple listbox");
 
     reset()
-    synthesizeKey("a", {});
-    check(false, "'A' key on multiple listbox");
+    synthesizeKey("a", {code: "KeyA"});
+    check(false, true, "'A' key on multiple listbox");
   });
 
   multipleListbox.removeEventListener("keydown", onKeydown);
   multipleListbox.removeEventListener("keypress", onKeypress);
   SpecialPowers.removeSystemEventListener(multipleListbox, "keydown", onkeydownInSystemEventGroup, false);
 
 
 
@@ -272,82 +283,82 @@ function runTests()
 
   combobox.focus();
 
   [ false, true ].forEach(function (consume) {
     doPreventDefault = consume;
     if (!kIsMac) {
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_DOWN", {});
-        check(true, "DownArrow key on combobox #" + i);
+        synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"});
+        check(true, false, "'ArrowDown' key on combobox #" + i);
       }
 
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_UP", {});
-        check(true, "UpArrow key on combobox #" + i);
+        synthesizeKey("KEY_ArrowUp", {code: "ArrowUp"});
+        check(true, false, "'ArrowUp' key on combobox #" + i);
       }
     } else {
       todo(false, "Make this test work on OSX");
     }
 
     for (var i = 0; i < combobox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_RIGHT", {});
-      check(true, "RightArrow key on combobox #" + i);
+      synthesizeKey("KEY_ArrowRight", {code: "ArrowRight"});
+      check(true, false, "'ArrowRight' key on combobox #" + i);
     }
 
     for (var i = 0; i < combobox.options.length + 1; i++) {
       reset()
-      synthesizeKey("VK_LEFT", {});
-      check(true, "LeftArrow key on combobox #" + i);
+      synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"});
+      check(true, false, "'ArrowLeft' key on combobox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_DOWN", {});
-      check(true, "PageDown key on combobox #" + i);
+      synthesizeKey("KEY_PageDown", {code: "PageDown"});
+      check(true, false, "'PageDown' key on combobox #" + i);
     }
 
     for (var i = 0; i < 4; i++) {
       reset()
-      synthesizeKey("VK_PAGE_UP", {});
-      check(true, "PageUp key on combobox #" + i);
+      synthesizeKey("KEY_PageUp", {code: "PageUp"});
+      check(true, false, "'PageUp' key on combobox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_END", {});
-      check(true, "End key on combobox #" + i);
+      synthesizeKey("KEY_End", {code: "End"});
+      check(true, false, "'End' key on combobox #" + i);
     }
 
     for (var i = 0; i < 2; i++) {
       reset()
-      synthesizeKey("VK_HOME", {});
-      check(true, "Home key on combobox #" + i);
+      synthesizeKey("KEY_Home", {code: "Home"});
+      check(true, false, "'Home' key on combobox #" + i);
     }
 
     reset()
-    synthesizeKey("VK_RETURN", {});
-    check(false, "Enter key on combobox");
+    synthesizeKey("KEY_Enter", {code: "Enter"});
+    check(false, true, "'Enter' key on combobox");
 
     reset()
-    synthesizeKey("VK_ESCAPE", {});
-    check(true, "Esc key on combobox");
+    synthesizeKey("KEY_Escape", {code: "Escape"});
+    check(true, false, "'Escape' key on combobox");
 
     if (!kIsWin) {
       reset()
-      synthesizeKey("VK_F4", {});
-      check(false, "F4 key on combobox");
+      synthesizeKey("KEY_F4", {code: "F4"});
+      check(false, false, "'F4' key on combobox");
     }
 
     reset()
-    synthesizeKey("a", {});
-    check(false, "'A' key on combobox");
+    synthesizeKey("a", {code: "KeyA"});
+    check(false, true, "'A' key on combobox");
   });
 
   function finish()
   {
     combobox.removeEventListener("keydown", onKeydown);
     combobox.removeEventListener("keypress", onKeypress);
     SpecialPowers.removeSystemEventListener(combobox, "keydown", onkeydownInSystemEventGroup, false);
     SimpleTest.finish();
@@ -360,103 +371,103 @@ function runTests()
     finish();
     return;
   }
 
   function testDropDown(aCallback)
   {
     testOpenDropDown(function () {
       reset()
-      synthesizeKey("VK_DOWN", { altKey: true });
+      synthesizeKey("KEY_ArrowDown", {code: "ArrowDown", altKey: true});
     }, function () {
-      check(true, "Alt + DownArrow key on combobox at opening dropdown");
+      check(true, false, "Alt + DownArrow key on combobox at opening dropdown");
 
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_DOWN", {});
-        check(true, "DownArrow key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_ArrowDown", {code: "ArrowDown"});
+        check(true, false, "'ArrowDown' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_UP", {});
-        check(true, "UpArrow key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_ArrowUp", {code: "ArrowUp"});
+        check(true, false, "'ArrowUp' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_RIGHT", {});
-        check(true, "RightArrow key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_ArrowRight", {code: "ArrowRight"});
+        check(true, false, "'ArrowRight' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < combobox.options.length + 1; i++) {
         reset()
-        synthesizeKey("VK_LEFT", {});
-        check(true, "LeftArrow key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_ArrowLeft", {code: "ArrowLeft"});
+        check(true, false, "'ArrowLeft' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < 4; i++) {
         reset()
-        synthesizeKey("VK_PAGE_DOWN", {});
-        check(true, "PageDown key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_PageDown", {code: "PageDown"});
+        check(true, false, "'PageDown' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < 4; i++) {
         reset()
-        synthesizeKey("VK_PAGE_UP", {});
-        check(true, "PageUp key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_PageUp", {code: "PageUp"});
+        check(true, false, "'PageUp' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < 2; i++) {
         reset()
-        synthesizeKey("VK_END", {});
-        check(true, "End key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_End", {code: "End"});
+        check(true, false, "'End' key on combobox during dropdown open #" + i);
       }
 
       for (var i = 0; i < 2; i++) {
         reset()
-        synthesizeKey("VK_HOME", {});
-        check(true, "Home key on combobox during dropdown open #" + i);
+        synthesizeKey("KEY_Home", {code: "Home"});
+        check(true, false, "'Home' key on combobox during dropdown open #" + i);
       }
 
       testCloseDropDown(function () {
         reset()
-        synthesizeKey("VK_RETURN", {});
+        synthesizeKey("KEY_Enter", {code: "Enter"});
       }, function () {
         testOpenDropDown(function () {
-          check(true, "Enter key on combobox at closing dropdown");
+          check(true, true, "'Enter' key on combobox at closing dropdown");
 
-          synthesizeKey("VK_UP", { altKey: true });
+          synthesizeKey("KEY_ArrowUp", {code: "ArrowUp", altKey: true});
         }, function () {
-          check(true, "Alt + UpArrow key on combobox at opening dropdown");
+          check(true, false, "'Alt' + 'ArrowUp' key on combobox at opening dropdown");
 
           testCloseDropDown(function () {
             reset()
-            synthesizeKey("VK_ESCAPE", {});
+            synthesizeKey("KEY_Escape", {code: "Escape"});
           }, function () {
-            check(true, "Esc key on combobox at closing dropdown");
+            check(true, false, "'Escape' key on combobox at closing dropdown");
 
             // F4 key opens/closes dropdown only on Windows. So, other platforms
             // don't need to do anymore.
             if (!kIsWin) {
               aCallback();
               return;
             }
 
             testOpenDropDown(function () {
               reset()
-              synthesizeKey("VK_F4", {});
+              synthesizeKey("KEY_F4", {code: "F4"});
             }, function () {
-              check(true, "F4 key on combobox at opening dropdown on Windows");
+              check(true, false, "'F4' key on combobox at opening dropdown on Windows");
 
               testCloseDropDown(function () {
                 reset()
-                synthesizeKey("VK_F4", {});
+                synthesizeKey("KEY_F4", {code: "F4"});
               }, function () {
-                check(true, "F4 key on combobox at closing dropdown on Windows");
+                check(true, false, "'F4' key on combobox at closing dropdown on Windows");
 
                 aCallback();
                 return;
               });
             });
           });
         });
       });
--- a/testing/mochitest/tests/Harness_sanity/test_sanityEventUtils.html
+++ b/testing/mochitest/tests/Harness_sanity/test_sanityEventUtils.html
@@ -25,46 +25,57 @@
 <p>blah blah blah blah</p>
 <p>blah blah blah blah</p>
 <p>blah blah blah blah</p>
 <p>blah blah blah blah</p>
 <p>blah blah blah blah</p>
 <p>blah blah blah blah</p>
 </div>
 <script class="testbody" type="text/javascript">
+const kStrictKeyPressEvents =
+  SpecialPowers.getBoolPref("dom.keyboardevent.keypress.dispatch_non_printable_keys_only_system_group_in_content");
+
 info("\nProfile::EventUtilsLoadTime: " + (loadTime - start) + "\n");
 function starttest() {
   SimpleTest.waitForFocus(
     function () {
       SimpleTest.waitForExplicitFinish();
       var startTime = new Date();
       var check = false;
       
       /* test send* functions */
       $("testMouseEvent").addEventListener("click", function() { check=true; });
       sendMouseEvent({type:'click'}, "testMouseEvent");
       is(check, true, 'sendMouseEvent should dispatch click event');
       
       check = false;
-      $("testKeyEvent").addEventListener("keypress", function() { check = true; });
+      $("testKeyEvent").addEventListener("keypress", function() { check = true; }, {once: true});
       $("testKeyEvent").focus();
       sendChar("x");
       is($("testKeyEvent").value, "x", "sendChar should work");
       is(check, true, "sendChar should dispatch keyPress");
       $("testKeyEvent").value = "";
     
       $("testStrEvent").focus();
       sendString("string");
       is($("testStrEvent").value, "string", "sendString should work");
       $("testStrEvent").value = "";
     
-      check = false;
+      var keydown = false;
+      var keypress = false;
       $("testKeyEvent").focus();
+      $("testKeyEvent").addEventListener("keydown", function() { keydown = true; }, {once: true});
+      $("testKeyEvent").addEventListener("keypress", function() { keypress = true; }, {once: true});
       sendKey("DOWN");
-      is(check, true, "sendKey should dispatch keyPress");
+      ok(keydown, "sendKey should dispatch keyDown");
+      if (kStrictKeyPressEvents) {
+        ok(!keypress, "sendKey shouldn't dispatch keyPress for non-printable key");
+      } else {
+        ok(keypress, "sendKey should dispatch keyPress even for non-printable key");
+      }
     
       /* test synthesizeMouse* */
       //focus trick enables us to run this in iframes
       $("radioTarget1").addEventListener('focus', function (aEvent) {
         synthesizeMouse($("radioTarget1"), 1, 1, {});
         is($("radioTarget1").checked, true, "synthesizeMouse should work")
         $("radioTarget1").checked = false;
         disableNonTestMouseEvents(true);
author	Masayuki Nakano <masayuki@d-toybox.com>
	Fri, 02 Feb 2018 18:10:22 +0900
changeset 750479	0f9d29f3c451a16f30f1b949bb44d175cda16334
parent 750383	27e993937c984b0e2bd05aeb17d791c7c036ad21
push id	97677
push user	masayuki@d-toybox.com
push date	Fri, 02 Feb 2018 12:08:46 +0000
reviewers	smaug
bugs	1435180
milestone	60.0a1
browser/base/content/test/permissions/browser_permissions.js		file \| annotate \| diff \| comparison \| revisions
browser/base/content/test/permissions/permissions.html		file \| annotate \| diff \| comparison \| revisions
browser/components/resistfingerprinting/test/browser/browser_spoofing_keyboard_event.js		file \| annotate \| diff \| comparison \| revisions
devtools/client/shared/test/browser_treeWidget_keyboard_interaction.js		file \| annotate \| diff \| comparison \| revisions
dom/events/test/test_dom_keyboard_event.html		file \| annotate \| diff \| comparison \| revisions
dom/html/test/browser_fullscreen-api-keys.js		file \| annotate \| diff \| comparison \| revisions
dom/html/test/forms/test_input_number_key_events.html		file \| annotate \| diff \| comparison \| revisions
dom/html/test/test_bug1295719_event_sequence_for_arrow_keys.html		file \| annotate \| diff \| comparison \| revisions
dom/html/test/test_bug633058.html		file \| annotate \| diff \| comparison \| revisions
layout/forms/test/test_bug935876.html		file \| annotate \| diff \| comparison \| revisions
testing/mochitest/tests/Harness_sanity/test_sanityEventUtils.html		file \| annotate \| diff \| comparison \| revisions