Promote createMockKeyEvent() to ChromeVoxNextE2ETest.

Promote createMockKeyEvent to avoid redeclarations in multiple files.
Also use KeyCode where possible. This change is a pure refactor.

Bug: N/A
Change-Id: I300c3cc0e02fd5610092dd8b39672acb7f96c9b6
AX-Relnotes: N/A
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2459631
Commit-Queue: Akihiro Ota <akihiroota@chromium.org>
Reviewed-by: David Tseng <dtseng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#815302}

chrome/browser/resources/chromeos/accessibility/chromevox/background/keyboard_handler_test.js

@@ -13,18 +13,6 @@ ChromeVoxBackgroundKeyboardHandlerTest = class extends ChromeVoxNextE2ETest {
   setUp() {
     window.keyboardHandler = new BackgroundKeyboardHandler();
   }
-
-  createMockKeyEvent(keyCode, opt_modifiers) {
-    const modifiers = opt_modifiers === undefined ? {} : opt_modifiers;
-    const keyEvent = {};
-    keyEvent.keyCode = keyCode;
-    for (const key in modifiers) {
-      keyEvent[key] = modifiers[key];
-    }
-    keyEvent.preventDefault = _ => {};
-    keyEvent.stopPropagation = _ => {};
-    return keyEvent;
-  }
 };
 
 
@@ -57,7 +45,7 @@ TEST_F('ChromeVoxBackgroundKeyboardHandlerTest', 'PassThroughMode', function() {
     assertEquals(0, keyboardHandler.passedThroughKeyDowns_.size);
 
     // Send the pass through command: Search+Shift+Escape.
-    const search = this.createMockKeyEvent(91, {metaKey: true});
+    const search = this.createMockKeyEvent(KeyCode.SEARCH, {metaKey: true});
     keyboardHandler.onKeyDown(search);
     assertEquals(1, keyboardHandler.eatenKeyDowns_.size);
     assertEquals(0, keyboardHandler.passedThroughKeyDowns_.size);
@@ -65,15 +53,15 @@ TEST_F('ChromeVoxBackgroundKeyboardHandlerTest', 'PassThroughMode', function() {
     assertUndefined(ChromeVox.passThroughMode);
 
     const searchShift =
-        this.createMockKeyEvent(16, {metaKey: true, shiftKey: true});
+        this.createMockKeyEvent(KeyCode.SHIFT, {metaKey: true, shiftKey: true});
     keyboardHandler.onKeyDown(searchShift);
     assertEquals(2, keyboardHandler.eatenKeyDowns_.size);
     assertEquals(0, keyboardHandler.passedThroughKeyDowns_.size);
     assertEquals('no_pass_through', keyboardHandler.passThroughState_);
     assertUndefined(ChromeVox.passThroughMode);
 
-    const searchShiftEsc =
-        this.createMockKeyEvent(27, {metaKey: true, shiftKey: true});
+    const searchShiftEsc = this.createMockKeyEvent(
+        KeyCode.ESCAPE, {metaKey: true, shiftKey: true});
     keyboardHandler.onKeyDown(searchShiftEsc);
     assertEquals(3, keyboardHandler.eatenKeyDowns_.size);
     assertEquals(0, keyboardHandler.passedThroughKeyDowns_.size);
@@ -109,8 +97,8 @@ TEST_F('ChromeVoxBackgroundKeyboardHandlerTest', 'PassThroughMode', function() {
     assertEquals('pending_shortcut_keyups', keyboardHandler.passThroughState_);
     assertTrue(ChromeVox.passThroughMode);
 
-    const searchCtrl =
-        this.createMockKeyEvent(17, {metaKey: true, ctrlKey: true});
+    const searchCtrl = this.createMockKeyEvent(
+        KeyCode.CONTROL, {metaKey: true, ctrlKey: true});
     keyboardHandler.onKeyDown(searchCtrl);
     assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
     assertEquals(2, keyboardHandler.passedThroughKeyDowns_.size);
@@ -118,7 +106,7 @@ TEST_F('ChromeVoxBackgroundKeyboardHandlerTest', 'PassThroughMode', function() {
     assertTrue(ChromeVox.passThroughMode);
 
     const searchCtrlM =
-        this.createMockKeyEvent(77, {metaKey: true, ctrlKey: true});
+        this.createMockKeyEvent(KeyCode.M, {metaKey: true, ctrlKey: true});
     keyboardHandler.onKeyDown(searchCtrlM);
     assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
     assertEquals(3, keyboardHandler.passedThroughKeyDowns_.size);
@@ -156,17 +144,17 @@ TEST_F(
 
         // Send some random keys; ensure the pass through state variables never
         // change.
-        const search = this.createMockKeyEvent(91, {metaKey: true});
+        const search = this.createMockKeyEvent(KeyCode.SEARCH, {metaKey: true});
         keyboardHandler.onKeyDown(search);
         assertNoPassThrough();
 
-        const searchShift =
-            this.createMockKeyEvent(16, {metaKey: true, shiftKey: true});
+        const searchShift = this.createMockKeyEvent(
+            KeyCode.SHIFT, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShift);
         assertNoPassThrough();
 
         const searchShiftM =
-            this.createMockKeyEvent(77, {metaKey: true, shiftKey: true});
+            this.createMockKeyEvent(KeyCode.M, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShiftM);
         assertNoPassThrough();
 
@@ -179,13 +167,15 @@ TEST_F(
         keyboardHandler.onKeyUp(search);
         assertNoPassThrough();
 
-        keyboardHandler.onKeyDown(this.createMockKeyEvent(65));
+        keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.A));
         assertNoPassThrough();
 
-        keyboardHandler.onKeyDown(this.createMockKeyEvent(65, {altKey: true}));
+        keyboardHandler.onKeyDown(
+            this.createMockKeyEvent(KeyCode.A, {altKey: true}));
         assertNoPassThrough();
 
-        keyboardHandler.onKeyUp(this.createMockKeyEvent(65, {altKey: true}));
+        keyboardHandler.onKeyUp(
+            this.createMockKeyEvent(KeyCode.A, {altKey: true}));
         assertNoPassThrough();
       });
     });
@@ -195,23 +185,23 @@ TEST_F(
     function() {
       this.runWithLoadedTree('<p>test</p>', function() {
         // Send a few key downs.
-        const search = this.createMockKeyEvent(91, {metaKey: true});
+        const search = this.createMockKeyEvent(KeyCode.SEARCH, {metaKey: true});
         keyboardHandler.onKeyDown(search);
         assertEquals(1, keyboardHandler.eatenKeyDowns_.size);
 
-        const searchShift =
-            this.createMockKeyEvent(16, {metaKey: true, shiftKey: true});
+        const searchShift = this.createMockKeyEvent(
+            KeyCode.SHIFT, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShift);
         assertEquals(2, keyboardHandler.eatenKeyDowns_.size);
 
         const searchShiftM =
-            this.createMockKeyEvent(77, {metaKey: true, shiftKey: true});
+            this.createMockKeyEvent(KeyCode.M, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShiftM);
         assertEquals(3, keyboardHandler.eatenKeyDowns_.size);
 
         // Now, send a key down, but no modifiers set, which is impossible to
         // actually press. This key is not eaten.
-        const m = this.createMockKeyEvent(77, {});
+        const m = this.createMockKeyEvent(KeyCode.M, {});
         keyboardHandler.onKeyDown(m);
         assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
 
@@ -230,26 +220,26 @@ TEST_F(
         ChromeVox.passThroughMode = true;
 
         // Send a few key downs (which are passed through).
-        const search = this.createMockKeyEvent(91, {metaKey: true});
+        const search = this.createMockKeyEvent(KeyCode.SEARCH, {metaKey: true});
         keyboardHandler.onKeyDown(search);
         assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
         assertEquals(1, keyboardHandler.passedThroughKeyDowns_.size);
 
-        const searchShift =
-            this.createMockKeyEvent(16, {metaKey: true, shiftKey: true});
+        const searchShift = this.createMockKeyEvent(
+            KeyCode.SHIFT, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShift);
         assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
         assertEquals(2, keyboardHandler.passedThroughKeyDowns_.size);
 
         const searchShiftM =
-            this.createMockKeyEvent(77, {metaKey: true, shiftKey: true});
+            this.createMockKeyEvent(KeyCode.M, {metaKey: true, shiftKey: true});
         keyboardHandler.onKeyDown(searchShiftM);
         assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
         assertEquals(3, keyboardHandler.passedThroughKeyDowns_.size);
 
         // Now, send a key down, but no modifiers set, which is impossible to
         // actually press. This is passed through, so the count resets to 1.
-        const m = this.createMockKeyEvent(77, {});
+        const m = this.createMockKeyEvent(KeyCode.M, {});
         keyboardHandler.onKeyDown(m);
         assertEquals(0, keyboardHandler.eatenKeyDowns_.size);
         assertEquals(1, keyboardHandler.passedThroughKeyDowns_.size);

chrome/browser/resources/chromeos/accessibility/chromevox/background/user_action_monitor_test.js

@@ -9,32 +9,6 @@ GEN_INCLUDE(['../testing/chromevox_next_e2e_test_base.js']);
  * Test fixture for UserActionMonitor.
  */
 ChromeVoxUserActionMonitorTest = class extends ChromeVoxNextE2ETest {
-  /**
-   * Create mock event object.
-   * @param {number} keyCode
-   * @param {{altGraphKey: boolean=,
-   *         altKey: boolean=,
-   *         ctrlKey: boolean=,
-   *         metaKey: boolean=,
-   *         searchKeyHeld: boolean=,
-   *         shiftKey: boolean=,
-   *         stickyMode: boolean=,
-   *         prefixKey: boolean=}=} opt_modifiers
-   * @return {Object} The mock event.
-   */
-  createMockKeyDownEvent(keyCode, opt_modifiers) {
-    const modifiers = opt_modifiers === undefined ? {} : opt_modifiers;
-    const mockEvent = {};
-    mockEvent.keyCode = keyCode;
-    for (const key in modifiers) {
-      mockEvent[key] = modifiers[key];
-    }
-
-    mockEvent.preventDefault = () => {};
-    mockEvent.stopPropagation = () => {};
-    return mockEvent;
-  }
-
   /**
    * Returns the start node of the current ChromeVox range.
    * @return {AutomationNode}
@@ -95,7 +69,7 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'ActionUnitTest', function() {
     const keySequenceActionOne = UserActionMonitor.Action.fromActionInfo(
         {type: 'key_sequence', value: {keys: {keyCode: [KeyCode.SPACE]}}});
     const keySequenceActionTwo = new UserActionMonitor.Action(
-        'key_sequence', new KeySequence(this.createMockKeyDownEvent(65)));
+        'key_sequence', new KeySequence(this.createMockKeyEvent(KeyCode.A)));
     const gestureActionOne = UserActionMonitor.Action.fromActionInfo(
         {type: 'gesture', value: 'swipeUp1'});
     const gestureActionTwo =
@@ -171,7 +145,8 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'Errors', function() {
     assertTrue(finished);
 
     try {
-      monitor.onKeySequence(new KeySequence(this.createMockKeyDownEvent(32)));
+      monitor.onKeySequence(
+          new KeySequence(this.createMockKeyEvent(KeyCode.SPACE)));
       assertTrue(false);  // Shouldn't execute.
     } catch (error) {
       assertEquals(
@@ -252,14 +227,14 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'SingleKey', function() {
     const onFinished = () => finished = true;
 
     ChromeVoxState.instance.createUserActionMonitor(actions, onFinished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.LEFT));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.LEFT));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.LEFT));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.LEFT));
     assertFalse(finished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.RIGHT));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.RIGHT));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.RIGHT));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.RIGHT));
     assertFalse(finished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.SPACE));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.SPACE));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.SPACE));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.SPACE));
     assertTrue(finished);
   });
 });
@@ -277,21 +252,21 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'MultipleKeys', function() {
     const onFinished = () => finished = true;
 
     ChromeVoxState.instance.createUserActionMonitor(actions, onFinished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.O));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.O));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.O));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.O));
     assertFalse(finished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.B));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.B));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.B));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.B));
     assertFalse(finished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.SEARCH));
-    keyboardHandler.onKeyUp(this.createMockKeyDownEvent(KeyCode.SEARCH));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.SEARCH));
+    keyboardHandler.onKeyUp(this.createMockKeyEvent(KeyCode.SEARCH));
     assertFalse(finished);
     keyboardHandler.onKeyDown(
-        this.createMockKeyDownEvent(KeyCode.O, {searchKeyHeld: true}));
+        this.createMockKeyEvent(KeyCode.O, {searchKeyHeld: true}));
     assertFalse(finished);
     keyboardHandler.onKeyUp(
-        this.createMockKeyDownEvent(KeyCode.O, {searchKeyHeld: true}));
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(KeyCode.B));
+        this.createMockKeyEvent(KeyCode.O, {searchKeyHeld: true}));
+    keyboardHandler.onKeyDown(this.createMockKeyEvent(KeyCode.B));
     assertTrue(finished);
   });
 });
@@ -320,9 +295,9 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'MultipleKeySequences', function() {
     const onFinished = () => finished = true;
 
     const altShiftLSequence = new KeySequence(
-        this.createMockKeyDownEvent(76, {altKey: true, shiftKey: true}));
+        this.createMockKeyEvent(KeyCode.L, {altKey: true, shiftKey: true}));
     const altShiftSSequence = new KeySequence(
-        this.createMockKeyDownEvent(83, {altKey: true, shiftKey: true}));
+        this.createMockKeyEvent(KeyCode.S, {altKey: true, shiftKey: true}));
     let monitor;
     mockFeedback
         .call(() => {
@@ -365,13 +340,13 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'BlockCommands', function() {
     const onFinished = () => finished = true;
 
     const nextObject =
-        this.createMockKeyDownEvent(KeyCode.RIGHT, {searchKeyHeld: true});
+        this.createMockKeyEvent(KeyCode.RIGHT, {searchKeyHeld: true});
     const nextLine =
-        this.createMockKeyDownEvent(40 /* ArrowDown */, {searchKeyHeld: true});
+        this.createMockKeyEvent(KeyCode.DOWN, {searchKeyHeld: true});
     const previousObject =
-        this.createMockKeyDownEvent(KeyCode.LEFT, {searchKeyHeld: true});
+        this.createMockKeyEvent(KeyCode.LEFT, {searchKeyHeld: true});
     const previousLine =
-        this.createMockKeyDownEvent(38 /* ArrowUp */, {searchKeyHeld: true});
+        this.createMockKeyEvent(KeyCode.UP, {searchKeyHeld: true});
 
     ChromeVoxState.instance.createUserActionMonitor(actions, onFinished);
     mockFeedback.expectSpeech('Start')
@@ -427,15 +402,15 @@ TEST_F('ChromeVoxUserActionMonitorTest', 'CloseChromeVox', function() {
     assertFalse(closed);
     assertFalse(finished);
     keyboardHandler.onKeyDown(
-        this.createMockKeyDownEvent(KeyCode.CONTROL, {ctrlKey: true}));
+        this.createMockKeyEvent(KeyCode.CONTROL, {ctrlKey: true}));
     assertFalse(closed);
     assertFalse(finished);
-    keyboardHandler.onKeyDown(this.createMockKeyDownEvent(
-        KeyCode.ALT, {ctrlKey: true, altKey: true}));
+    keyboardHandler.onKeyDown(
+        this.createMockKeyEvent(KeyCode.ALT, {ctrlKey: true, altKey: true}));
     assertFalse(closed);
     assertFalse(finished);
     keyboardHandler.onKeyDown(
-        this.createMockKeyDownEvent(KeyCode.Z, {ctrlKey: true, altKey: true}));
+        this.createMockKeyEvent(KeyCode.Z, {ctrlKey: true, altKey: true}));
     assertTrue(closed);
     // |finished| remains false since we didn't press the expected key sequence.
     assertFalse(finished);

chrome/browser/resources/chromeos/accessibility/chromevox/panel/tutorial_test.js

@@ -499,20 +499,8 @@ TEST_F('ChromeVoxTutorialTest', 'QuickOrientationLessonTest', function() {
     const getRangeStart = () => {
       return ChromeVoxState.instance.getCurrentRange().start.node;
     };
-    const createMockKeyEvent = (keyCode, opt_modifiers) => {
-      const modifiers = opt_modifiers === undefined ? {} : opt_modifiers;
-      const mockEvent = {};
-      mockEvent.keyCode = keyCode;
-      for (const key in modifiers) {
-        mockEvent[key] = modifiers[key];
-      }
-
-      mockEvent.preventDefault = () => {};
-      mockEvent.stopPropagation = () => {};
-      return mockEvent;
-    };
     const simulateKeyPress = (keyCode, opt_modifiers) => {
-      const keyEvent = createMockKeyEvent(keyCode, opt_modifiers);
+      const keyEvent = this.createMockKeyEvent(keyCode, opt_modifiers);
       keyboardHandler.onKeyDown(keyEvent);
       keyboardHandler.onKeyUp(keyEvent);
     };

chrome/browser/resources/chromeos/accessibility/chromevox/testing/chromevox_next_e2e_test_base.js

@@ -43,6 +43,31 @@ ChromeVoxNextE2ETest = class extends ChromeVoxE2ETest {
     return mockFeedback;
   }
 
+  /**
+   * Create a mock event object.
+   * @param {number} keyCode
+   * @param {{altGraphKey: boolean=,
+   *         altKey: boolean=,
+   *         ctrlKey: boolean=,
+   *         metaKey: boolean=,
+   *         searchKeyHeld: boolean=,
+   *         shiftKey: boolean=,
+   *         stickyMode: boolean=,
+   *         prefixKey: boolean=}=} opt_modifiers
+   * @return {Object} The mock event.
+   */
+  createMockKeyEvent(keyCode, opt_modifiers) {
+    const modifiers = opt_modifiers === undefined ? {} : opt_modifiers;
+    const keyEvent = {};
+    keyEvent.keyCode = keyCode;
+    for (const key in modifiers) {
+      keyEvent[key] = modifiers[key];
+    }
+    keyEvent.preventDefault = _ => {};
+    keyEvent.stopPropagation = _ => {};
+    return keyEvent;
+  }
+
   /**
    * Create a function which performs the command |cmd|.
    * @param {string} cmd