mustash: Use ui::chromeos::EventRewriter in mus

services/ui/ws/display.cc

Index: services/ui/ws/display.cc
diff --git a/services/ui/ws/display.cc b/services/ui/ws/display.cc
index 7fc5771a689b12454b47d45b124b35f174ac2284..977e8baf3ba2a6097d0aa7d36f9e7ae024a2df6f 100644
--- a/services/ui/ws/display.cc
+++ b/services/ui/ws/display.cc
@@ -8,6 +8,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
@@ -28,6 +29,7 @@
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/display/screen.h"
+#include "ui/events/event_rewriter.h"
 
 namespace ui {
 namespace ws {
@@ -270,13 +272,54 @@ bool Display::IsInHighContrastMode() {
 }
 
 void Display::OnEvent(const ui::Event& event) {
+  // Run UserActivityMonitor::OnUserActivity() for active user before exiting
+  // this function.
+  auto* activity_monitor = window_server_->GetUserActivityMonitorForUser(
+      window_server_->user_id_tracker()->active_id());
+  base::ScopedClosureRunner scoped_runner(

[sky, 2017/03/15 19:48:11]

Do we really need a ScopedClosureRunner? Can you call OnUserActivity right away?
If the event is discarded do we still want to call OnUserActivity?

[Peng, 2017/03/16 17:28:57]

This function has several return statements, using ScopedClosureRunner may make
code simple, and it will be unlikely to have bugs in future.

I guess calling OnUserActivity() is for tracing last user event, right?
Maybe use it for keep screen on. In that case, I think we will want to keep the
screen on by any event, even if the event is consumed by event rewriter. For
example, the sticky keys controller may consume the CTRL release event and send
it back to UI later.

[sky, 2017/03/16 20:23:07]

Sorry for not being clear. I wasn't suggesting you don't call OnUserActivity.
Rather I'm asking if you can call OnUserActivity() directly right here and no
ScopedClosureRunner.

+      base::Bind(&UserActivityMonitor::OnUserActivity,
+                 base::Unretained(activity_monitor)));
+
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
-  if (display_root)
-    display_root->window_manager_state()->ProcessEvent(event, GetId());
-  window_server_
-      ->GetUserActivityMonitorForUser(
-          window_server_->user_id_tracker()->active_id())
-      ->OnUserActivity();
+  if (!display_root)
+    return;
+
+  std::unique_ptr<ui::Event> rewritten_event;
+  auto status = ui::EVENT_REWRITE_CONTINUE;

[sky, 2017/03/15 19:48:11]

Please don't overuse auto, it's make the code harder to read. I would prefer if
you didn't use auto in any of the cases you have here.

[Peng, 2017/03/16 17:28:57]

Done.

+  auto* event_rewriter = display_manager()->event_rewriter();
+
+  // |event_rewriter| is null for non-ChromeOS build.
+  if (event_rewriter)
+    status = event_rewriter->RewriteEvent(event, &rewritten_event);
+
+  if (status == ui::EVENT_REWRITE_DISCARD) {
+    DCHECK(!rewritten_event);
+    return;
+  }
+
+  auto* wm_state = display_root->window_manager_state();
+  if (status == ui::EVENT_REWRITE_CONTINUE) {
+    DCHECK(!rewritten_event);
+    wm_state->ProcessEvent(event, GetId());
+    return;
+  }
+
+  DCHECK(status == ui::EVENT_REWRITE_REWRITTEN ||
+         status == ui::EVENT_REWRITE_DISPATCH_ANOTHER);
+  DCHECK(rewritten_event);
+  wm_state->ProcessEvent(*rewritten_event, GetId());
+
+  while (status == ui::EVENT_REWRITE_DISPATCH_ANOTHER) {
+    std::unique_ptr<Event> new_event;
+    status = event_rewriter->NextDispatchEvent(*rewritten_event, &new_event);
+    if (status == ui::EVENT_REWRITE_DISCARD)
+      break;
+    DCHECK_NE(EVENT_REWRITE_CONTINUE, status);
+
+    DCHECK(new_event);
+    wm_state->ProcessEvent(*new_event, GetId());
+    rewritten_event = std::move(new_event);
+  }
 }
 
 void Display::OnNativeCaptureLost() {