Migrate KeyboardDrivenEventRewriter to new EventRewriter API.

Bug: None
Test: ash_unittests
Change-Id: I62e018e0898f032bc947862750e542c0da9f91cb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2025167
Commit-Queue: Yuichiro Hanada <yhanada@chromium.org>
Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Kevin Schoedel <kpschoedel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737192}

ash/events/keyboard_driven_event_rewriter.cc

@@ -17,37 +17,30 @@ KeyboardDrivenEventRewriter::KeyboardDrivenEventRewriter() = default;
 
 KeyboardDrivenEventRewriter::~KeyboardDrivenEventRewriter() = default;
 
-ui::EventRewriteStatus KeyboardDrivenEventRewriter::RewriteForTesting(
+ui::EventDispatchDetails KeyboardDrivenEventRewriter::RewriteForTesting(
     const ui::Event& event,
-    std::unique_ptr<ui::Event>* rewritten_event) {
-  return Rewrite(event, rewritten_event);
+    const Continuation continuation) {
+  return Rewrite(event, continuation);
 }
 
-ui::EventRewriteStatus KeyboardDrivenEventRewriter::RewriteEvent(
+ui::EventDispatchDetails KeyboardDrivenEventRewriter::RewriteEvent(
     const ui::Event& event,
-    std::unique_ptr<ui::Event>* rewritten_event) {
+    const Continuation continuation) {
   if (!enabled_ ||
       Shell::Get()->session_controller()->IsActiveUserSessionStarted()) {
-    return ui::EVENT_REWRITE_CONTINUE;
+    return SendEvent(continuation, &event);
   }
 
-  return Rewrite(event, rewritten_event);
+  return Rewrite(event, continuation);
 }
 
-ui::EventRewriteStatus KeyboardDrivenEventRewriter::NextDispatchEvent(
-    const ui::Event& last_event,
-    std::unique_ptr<ui::Event>* new_event) {
-  NOTREACHED();
-  return ui::EVENT_REWRITE_CONTINUE;
-}
-
-ui::EventRewriteStatus KeyboardDrivenEventRewriter::Rewrite(
+ui::EventDispatchDetails KeyboardDrivenEventRewriter::Rewrite(
     const ui::Event& event,
-    std::unique_ptr<ui::Event>* rewritten_event) {
+    const Continuation continuation) {
   int flags = event.flags();
   const int kModifierMask = ui::EF_SHIFT_DOWN;
   if ((flags & kModifierMask) != kModifierMask)
-    return ui::EVENT_REWRITE_CONTINUE;
+    return SendEvent(continuation, &event);
 
   DCHECK(event.type() == ui::ET_KEY_PRESSED ||
          event.type() == ui::ET_KEY_RELEASED)
@@ -57,7 +50,7 @@ ui::EventRewriteStatus KeyboardDrivenEventRewriter::Rewrite(
 
   if (!keyboard_util::IsArrowKeyCode(key_code) && key_code != ui::VKEY_RETURN &&
       key_code != ui::VKEY_F6) {
-    return ui::EVENT_REWRITE_CONTINUE;
+    return SendEvent(continuation, &event);
   }
 
   ui::EventRewriterChromeOS::MutableKeyState state = {
@@ -76,9 +69,10 @@ ui::EventRewriteStatus KeyboardDrivenEventRewriter::Rewrite(
     }
   }
 
+  std::unique_ptr<ui::Event> rewritten_event;
   ui::EventRewriterChromeOS::BuildRewrittenKeyEvent(key_event, state,
-                                                    rewritten_event);
-  return ui::EVENT_REWRITE_REWRITTEN;
+                                                    &rewritten_event);
+  return SendEventFinally(continuation, rewritten_event.get());
 }
 
 }  // namespace ash

ash/events/keyboard_driven_event_rewriter.h

@@ -20,17 +20,13 @@ class ASH_EXPORT KeyboardDrivenEventRewriter : public ui::EventRewriter {
   ~KeyboardDrivenEventRewriter() override;
 
   // Calls Rewrite for testing.
-  ui::EventRewriteStatus RewriteForTesting(
-      const ui::Event& event,
-      std::unique_ptr<ui::Event>* new_event);
+  ui::EventDispatchDetails RewriteForTesting(const ui::Event& event,
+                                             const Continuation continuation);
 
   // EventRewriter overrides:
-  ui::EventRewriteStatus RewriteEvent(
+  ui::EventDispatchDetails RewriteEvent(
       const ui::Event& event,
-      std::unique_ptr<ui::Event>* new_event) override;
-  ui::EventRewriteStatus NextDispatchEvent(
-      const ui::Event& last_event,
-      std::unique_ptr<ui::Event>* new_event) override;
+      const Continuation continuation) override;
 
   void set_enabled(bool enabled) { enabled_ = enabled; }
   void set_arrow_to_tab_rewriting_enabled(bool enabled) {
@@ -38,8 +34,8 @@ class ASH_EXPORT KeyboardDrivenEventRewriter : public ui::EventRewriter {
   }
 
  private:
-  ui::EventRewriteStatus Rewrite(const ui::Event& event,
-                                 std::unique_ptr<ui::Event>* new_event);
+  ui::EventDispatchDetails Rewrite(const ui::Event& event,
+                                   const Continuation continuation);
 
   // If true, this rewriter is enabled. It is only active before user login.
   bool enabled_ = false;

ash/events/keyboard_driven_event_rewriter_unittest.cc

@@ -12,32 +12,61 @@
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
+#include "ui/events/test/test_event_rewriter_continuation.h"
 
 namespace ash {
 
+class TestEventRewriterContinuation
+    : public ui::test::TestEventRewriterContinuation {
+ public:
+  TestEventRewriterContinuation() = default;
+  ~TestEventRewriterContinuation() override = default;
+
+  ui::EventDispatchDetails SendEvent(const ui::Event* event) override {
+    passthrough_event = ui::Event::Clone(*event);
+    return ui::EventDispatchDetails();
+  }
+
+  ui::EventDispatchDetails SendEventFinally(const ui::Event* event) override {
+    rewritten_event = ui::Event::Clone(*event);
+    return ui::EventDispatchDetails();
+  }
+
+  ui::EventDispatchDetails DiscardEvent() override {
+    return ui::EventDispatchDetails();
+  }
+
+  std::unique_ptr<ui::Event> passthrough_event;
+  std::unique_ptr<ui::Event> rewritten_event;
+
+  base::WeakPtrFactory<TestEventRewriterContinuation> weak_ptr_factory_{this};
+  DISALLOW_COPY_AND_ASSIGN(TestEventRewriterContinuation);
+};
+
 class KeyboardDrivenEventRewriterTest : public testing::Test {
  public:
-  KeyboardDrivenEventRewriterTest() {}
+  KeyboardDrivenEventRewriterTest() = default;
 
-  ~KeyboardDrivenEventRewriterTest() override {}
+  ~KeyboardDrivenEventRewriterTest() override = default;
 
  protected:
   std::string GetRewrittenEventAsString(ui::KeyboardCode ui_keycode,
                                         int ui_flags,
                                         ui::EventType ui_type) {
+    TestEventRewriterContinuation continuation;
     ui::KeyEvent keyevent(ui_type, ui_keycode, ui_flags);
-    std::unique_ptr<ui::Event> rewritten_event;
-    ui::EventRewriteStatus status =
-        rewriter_.RewriteForTesting(keyevent, &rewritten_event);
-    return base::StringPrintf(
-        "ui_flags=%d status=%d",
-        rewritten_event ? rewritten_event->flags() : keyevent.flags(),
-        status);
+    rewriter_.RewriteForTesting(keyevent,
+                                continuation.weak_ptr_factory_.GetWeakPtr());
+
+    std::string result = "No event is sent by RewriteEvent.";
+    if (continuation.passthrough_event) {
+      result = base::StringPrintf("PassThrough ui_flags=%d",
+                                  continuation.passthrough_event->flags());
+    } else if (continuation.rewritten_event) {
+      result = base::StringPrintf("Rewritten ui_flags=%d",
+                                  continuation.rewritten_event->flags());
     }
-
-  std::string GetExpectedResultAsString(int ui_flags,
-                                        ui::EventRewriteStatus status) {
-    return base::StringPrintf("ui_flags=%d status=%u", ui_flags, status);
+    return result;
   }
 
   KeyboardDrivenEventRewriter rewriter_;
@@ -80,11 +109,9 @@ TEST_F(KeyboardDrivenEventRewriterTest, PassThrough) {
   };
 
   for (size_t i = 0; i < base::size(kTests); ++i) {
-    EXPECT_EQ(GetExpectedResultAsString(kTests[i].ui_flags,
-                                        ui::EVENT_REWRITE_CONTINUE),
+    EXPECT_EQ(base::StringPrintf("PassThrough ui_flags=%d", kTests[i].ui_flags),
               GetRewrittenEventAsString(kTests[i].ui_keycode,
-                                        kTests[i].ui_flags,
-                                        ui::ET_KEY_PRESSED))
+                                        kTests[i].ui_flags, ui::ET_KEY_PRESSED))
         << "Test case " << i;
   }
 }
@@ -105,11 +132,9 @@ TEST_F(KeyboardDrivenEventRewriterTest, Rewrite) {
   };
 
   for (size_t i = 0; i < base::size(kTests); ++i) {
-    EXPECT_EQ(GetExpectedResultAsString(ui::EF_NONE,
-                                        ui::EVENT_REWRITE_REWRITTEN),
+    EXPECT_EQ("Rewritten ui_flags=0",
               GetRewrittenEventAsString(kTests[i].ui_keycode,
-                                        kTests[i].ui_flags,
-                                        ui::ET_KEY_PRESSED))
+                                        kTests[i].ui_flags, ui::ET_KEY_PRESSED))
         << "Test case " << i;
   }
 }

ui/events/BUILD.gn

@@ -457,6 +457,7 @@ jumbo_static_library("test_support") {
     "test/test_event_processor.h",
     "test/test_event_rewriter.cc",
     "test/test_event_rewriter.h",
+    "test/test_event_rewriter_continuation.h",
     "test/test_event_source.cc",
     "test/test_event_source.h",
     "test/test_event_target.cc",

ui/events/test/test_event_rewriter_continuation.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_EVENTS_TEST_TEST_EVENT_REWRITER_CONTINUATION_H_
+#define UI_EVENTS_TEST_TEST_EVENT_REWRITER_CONTINUATION_H_
+
+#include "ui/events/event_rewriter_continuation.h"
+
+namespace ui {
+namespace test {
+
+// This interface exposes EventRewriterContinuation interface to
+// test code outside of ui/events.
+class TestEventRewriterContinuation : public ui::EventRewriterContinuation {
+ public:
+  TestEventRewriterContinuation() = default;
+  ~TestEventRewriterContinuation() override = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestEventRewriterContinuation);
+};
+
+}  // namespace test
+}  // namespace ui
+
+#endif  // UI_EVENTS_TEST_TEST_EVENT_REWRITER_CONTINUATION_H_