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

services/ui/ws/display.cc

 // Copyright 2015 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.
 
 #include "services/ui/ws/display.h"
 
 #include <set>
 #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"
 #include "services/ui/common/types.h"
 #include "services/ui/display/viewport_metrics.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/focus_controller.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree.h"
 #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 {
 
 Display::Display(WindowServer* window_server)
     : window_server_(window_server), last_cursor_(mojom::Cursor::CURSOR_NULL) {
   window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
 
@@ skipping 222 matching lines @@
 void Display::OnAcceleratedWidgetAvailable() {
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   InitWindowManagerDisplayRoots();
 }
 
 bool Display::IsInHighContrastMode() {
   return window_server_->IsActiveUserInHighContrastMode();
 }
 
 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() {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
   if (display_root)
     display_root->window_manager_state()->SetCapture(nullptr, kInvalidClientId);
 }
 
 void Display::OnViewportMetricsChanged(
     const display::ViewportMetrics& metrics) {
@@ skipping 91 matching lines @@
 }
 
 void Display::OnWindowManagerWindowTreeFactoryReady(
     WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
     CreateWindowManagerDisplayRootFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace ui