Reland "cros: Add alternate keys for interacting with window cycler (alt+tab)."

This is a reland of feab4f74

Original change's description:
> cros: Add alternate keys for interacting with window cycler (alt+tab).
> 
> Currently a user can only cycle the window cycle list using alt+tab or
> alt+shift+tab. Also, the user can only confirm their selection by
> releasing the alt key.
> 
> This CL improves the interactivity of window cycler by introducing the
> following changes. Pressing the left and right arrows now move the
> selection while the window cycler is open. Pressing enter or space
> now confirms the selection.
> 
>       WindowCycleControllerTest.KeysConfirmSelection
> 
> Test: WindowCycleControllerTest.LeftRightCycle,
> Bug: 1067327
> Change-Id: I03682c5545bf82415b9e71a4814bf5c1b0c196bc
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2358586
> Commit-Queue: Jeremy Chinsen <chinsenj@chromium.org>
> Reviewed-by: Sammie Quon <sammiequon@chromium.org>
> Reviewed-by: Xiaoqian Dai <xdai@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#800423}

Bug: 1067327
Change-Id: Ie05f898abe3565fca603b70450bf3a6d92a9caf7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2368467Reviewed-by: Xiaoqian Dai <xdai@chromium.org>
Commit-Queue: Jeremy Chinsen <chinsenj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800641}

ash/wm/window_cycle_controller_unittest.cc

@@ -901,6 +901,78 @@ TEST_F(InteractiveWindowCycleControllerTest, MouseHoverAndSelect) {
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 }
 
+// Tests that the left and right keys cycle after the cycle list has been
+// initialized.
+TEST_F(InteractiveWindowCycleControllerTest, LeftRightCycle) {
+  std::unique_ptr<Window> w0 = CreateTestWindow();
+  std::unique_ptr<Window> w1 = CreateTestWindow();
+  std::unique_ptr<Window> w2 = CreateTestWindow();
+  ui::test::EventGenerator* generator = GetEventGenerator();
+  WindowCycleController* controller = Shell::Get()->window_cycle_controller();
+
+  // Start cycle, simulating alt button being held down. Cycle right to the
+  // third item.
+  // Starting order of windows in cycle list is [2,1,0].
+  controller->StartCycling();
+  generator->PressKey(ui::VKEY_RIGHT, ui::EF_NONE);
+  generator->PressKey(ui::VKEY_RIGHT, ui::EF_NONE);
+  controller->CompleteCycling();
+  EXPECT_TRUE(wm::IsActiveWindow(w0.get()));
+
+  // Start cycle. Cycle right once, then left two times.
+  // Starting order of windows in cycle list is [0,2,1].
+  controller->StartCycling();
+  generator->PressKey(ui::VKEY_RIGHT, ui::EF_NONE);
+  generator->PressKey(ui::VKEY_LEFT, ui::EF_NONE);
+  generator->PressKey(ui::VKEY_LEFT, ui::EF_NONE);
+  controller->CompleteCycling();
+  EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
+
+  // Start cycle. Cycle right once, then left once, then right once.
+  // Starting order of windows in cycle list is [0,2,1].
+  controller->StartCycling();
+  generator->PressKey(ui::VKEY_LEFT, ui::EF_ALT_DOWN);
+  generator->PressKey(ui::VKEY_RIGHT, ui::EF_ALT_DOWN);
+  generator->PressKey(ui::VKEY_LEFT, ui::EF_ALT_DOWN);
+  controller->CompleteCycling();
+  EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
+}
+
+// Tests that pressing the space key, pressing the enter key, or releasing the
+// alt key during window cycle confirms a selection.
+TEST_F(InteractiveWindowCycleControllerTest, KeysConfirmSelection) {
+  std::unique_ptr<Window> w0 = CreateTestWindow();
+  std::unique_ptr<Window> w1 = CreateTestWindow();
+  std::unique_ptr<Window> w2 = CreateTestWindow();
+  ui::test::EventGenerator* generator = GetEventGenerator();
+  WindowCycleController* controller = Shell::Get()->window_cycle_controller();
+
+  // Start cycle, simulating alt button being held down. Cycle right once and
+  // complete cycle using space.
+  // Starting order of windows in cycle list is [2,1,0].
+  controller->StartCycling();
+  controller->HandleCycleWindow(WindowCycleController::FORWARD);
+  generator->PressKey(ui::VKEY_SPACE, ui::EF_NONE);
+  EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
+
+  // Start cycle, simulating alt button being held down. Cycle right once and
+  // complete cycle using enter.
+  // Starting order of windows in cycle list is [1,2,0].
+  controller->StartCycling();
+  controller->HandleCycleWindow(WindowCycleController::FORWARD);
+  generator->PressKey(ui::VKEY_RETURN, ui::EF_NONE);
+  EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
+
+  // Start cycle, simulating alt button being held down. Cycle right once and
+  // complete cycle by releasing alt key (Views uses VKEY_MENU for both left and
+  // right alt keys).
+  // Starting order of windows in cycle list is [2,1,0].
+  controller->StartCycling();
+  controller->HandleCycleWindow(WindowCycleController::FORWARD);
+  generator->ReleaseKey(ui::VKEY_MENU, ui::EF_NONE);
+  EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
+}
+
 // Tests that frame throttling starts and ends accordingly when window cycling
 // starts and ends.
 TEST_F(WindowCycleControllerTest, FrameThrottling) {

ash/wm/window_cycle_event_filter.cc

@@ -32,30 +32,76 @@ WindowCycleEventFilter::~WindowCycleEventFilter() {
 void WindowCycleEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   // Until the alt key is released, all key events except the trigger key press
   // (which is handled by the accelerator controller to call Step) are handled
-  // by this window cycle controller: https://crbug.com/340339.
-  bool is_trigger_key = event->key_code() == ui::VKEY_TAB ||
-                        (debug::DeveloperAcceleratorsEnabled() &&
-                         event->key_code() == ui::VKEY_W);
+  // by this window cycle controller: https://crbug.com/340339. When the window
+  // cycle list exists, right + left arrow keys are considered trigger keys and
+  // those two are handled by this.
+  const bool is_trigger_key = IsTriggerKey(event);
+  const bool is_exit_key = IsExitKey(event);
+
   if (!is_trigger_key || event->type() != ui::ET_KEY_PRESSED)
     event->StopPropagation();
-  if (is_trigger_key) {
-    if (event->type() == ui::ET_KEY_RELEASED) {
-      repeat_timer_.Stop();
-    } else if (event->type() == ui::ET_KEY_PRESSED && event->is_repeat() &&
-               !repeat_timer_.IsRunning()) {
-      repeat_timer_.Start(
-          FROM_HERE, base::TimeDelta::FromMilliseconds(180),
-          base::BindRepeating(
-              &WindowCycleController::HandleCycleWindow,
-              base::Unretained(Shell::Get()->window_cycle_controller()),
-              event->IsShiftDown() ? WindowCycleController::BACKWARD
-                                   : WindowCycleController::FORWARD));
-    }
-  } else if (event->key_code() == ui::VKEY_ESCAPE) {
+
+  if (is_trigger_key)
+    HandleTriggerKey(event);
+  else if (is_exit_key)
+    Shell::Get()->window_cycle_controller()->CompleteCycling();
+  else if (event->key_code() == ui::VKEY_ESCAPE)
     Shell::Get()->window_cycle_controller()->CancelCycling();
+}
+
+void WindowCycleEventFilter::HandleTriggerKey(ui::KeyEvent* event) {
+  if (event->type() == ui::ET_KEY_RELEASED) {
+    repeat_timer_.Stop();
+  } else if (ShouldRepeatKey(event)) {
+    repeat_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(180),
+        base::BindRepeating(
+            &WindowCycleController::HandleCycleWindow,
+            base::Unretained(Shell::Get()->window_cycle_controller()),
+            GetDirection(event)));
+  } else if (event->key_code() == ui::VKEY_LEFT ||
+             event->key_code() == ui::VKEY_RIGHT) {
+    Shell::Get()->window_cycle_controller()->HandleCycleWindow(
+        GetDirection(event));
   }
 }
 
+bool WindowCycleEventFilter::IsTriggerKey(ui::KeyEvent* event) const {
+  const bool interactive_trigger_key =
+      features::IsInteractiveWindowCycleListEnabled() &&
+      (event->key_code() == ui::VKEY_LEFT ||
+       event->key_code() == ui::VKEY_RIGHT);
+
+  return event->key_code() == ui::VKEY_TAB ||
+         (debug::DeveloperAcceleratorsEnabled() &&
+          event->key_code() == ui::VKEY_W) ||
+         interactive_trigger_key;
+}
+
+bool WindowCycleEventFilter::IsExitKey(ui::KeyEvent* event) const {
+  return features::IsInteractiveWindowCycleListEnabled() &&
+         (event->key_code() == ui::VKEY_RETURN ||
+          event->key_code() == ui::VKEY_SPACE);
+}
+
+bool WindowCycleEventFilter::ShouldRepeatKey(ui::KeyEvent* event) const {
+  return event->type() == ui::ET_KEY_PRESSED && event->is_repeat() &&
+         !repeat_timer_.IsRunning();
+}
+
+WindowCycleController::Direction WindowCycleEventFilter::GetDirection(
+    ui::KeyEvent* event) const {
+  DCHECK(IsTriggerKey(event));
+
+  // Move backward if left arrow, forward if right arrow, tab, or W. Shift flips
+  // the direction.
+  const bool left = event->key_code() == ui::VKEY_LEFT;
+  const bool shift = event->IsShiftDown();
+
+  return (left ^ shift) ? WindowCycleController::BACKWARD
+                        : WindowCycleController::FORWARD;
+}
+
 void WindowCycleEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (features::IsInteractiveWindowCycleListEnabled() &&
       Shell::Get()->window_cycle_controller()->IsEventInCycleView(event)) {

ash/wm/window_cycle_event_filter.h

@@ -6,6 +6,7 @@
 #define ASH_WM_WINDOW_CYCLE_EVENT_FILTER_H_
 
 #include "ash/ash_export.h"
+#include "ash/wm/window_cycle_controller.h"
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "ui/events/event_handler.h"
@@ -14,6 +15,7 @@ namespace ash {
 
 // Created by WindowCycleController when cycling through windows. Eats all key
 // events and stops cycling when the necessary key sequence is encountered.
+// Also allows users to cycle using right/left keys.
 class ASH_EXPORT WindowCycleEventFilter : public ui::EventHandler {
  public:
   WindowCycleEventFilter();
@@ -29,12 +31,32 @@ class ASH_EXPORT WindowCycleEventFilter : public ui::EventHandler {
     AltReleaseHandler();
     ~AltReleaseHandler() override;
 
+    // ui::EventHandler:
     void OnKeyEvent(ui::KeyEvent* event) override;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(AltReleaseHandler);
   };
 
+  // Depending on the values of |event| either repeatedly cycle through windows,
+  // stop repeatedly cycling through windows, or cycle once.
+  void HandleTriggerKey(ui::KeyEvent* event);
+
+  // Returns whether |event| is a trigger key (tab, left, right, w (when
+  // debugging)).
+  bool IsTriggerKey(ui::KeyEvent* event) const;
+
+  // Returns whether |event| is an exit key (return, space).
+  bool IsExitKey(ui::KeyEvent* event) const;
+
+  // Returns whether the window cycle should repeatedly cycle in the
+  // direction given by |event|.
+  bool ShouldRepeatKey(ui::KeyEvent* event) const;
+
+  // Returns the direction the window cycle should cycle depending on the
+  // combination of keys being pressed.
+  WindowCycleController::Direction GetDirection(ui::KeyEvent* event) const;
+
   // When the user holds Alt+Tab, this timer is used to send repeated
   // cycle commands to WindowCycleController. Note this is not accomplished
   // by marking the Alt+Tab accelerator as "repeatable" in the accelerator