Do not use ash in chromeos::EventRewriter.

chrome/browser/chromeos/events/event_rewriter.cc

 // Copyright 2014 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 "chrome/browser/chromeos/events/event_rewriter.h"
 
 #include <stddef.h>
 
 #include <vector>
 
-#include "ash/common/wm/window_state.h"
-#include "ash/sticky_keys/sticky_keys_controller.h"
-#include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/extensions/extension_commands_global_registry.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_manager/user_manager.h"
 #include "ui/base/ime/chromeos/ime_keyboard.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #include "ui/events/devices/input_device_manager.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
-#include "ui/wm/core/window_util.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
 // Get rid of macros from Xlib.h that conflicts with other parts of the code.
 #undef RootWindow
 #undef Status
 
 #include "ui/base/x/x11_util.h"
@@ skipping 250 matching lines @@
     case ui::DomCode::META_RIGHT:
       return right ? ui::DomCode::META_RIGHT : ui::DomCode::META_LEFT;
     default:
       break;
   }
   return code;
 }
 
 }  // namespace
 
-EventRewriter::EventRewriter(ash::StickyKeysController* sticky_keys_controller)
+EventRewriter::EventRewriter(ui::EventRewriter* sticky_keys_controller)
     : last_keyboard_device_id_(ui::ED_UNKNOWN_DEVICE),
       ime_keyboard_for_testing_(NULL),
       pref_service_for_testing_(NULL),
       sticky_keys_controller_(sticky_keys_controller),
       pressed_modifier_latches_(ui::EF_NONE),
       latched_modifier_latches_(ui::EF_NONE),
       used_modifier_latches_(ui::EF_NONE) {}
 
 EventRewriter::~EventRewriter() {}
 
@@ skipping 43 matching lines @@
 
 ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
     const ui::Event& last_event,
     std::unique_ptr<ui::Event>* new_event) {
   if (sticky_keys_controller_) {
     // In the case of sticky keys, we know what the events obtained here are:
     // modifier key releases that match the ones previously discarded. So, we
     // know that they don't have to be passed through the post-sticky key
     // rewriting phases, |RewriteExtendedKeys()| and |RewriteFunctionKeys()|,
     // because those phases do nothing with modifier key releases.
-    return sticky_keys_controller_->NextDispatchEvent(new_event);
+    return sticky_keys_controller_->NextDispatchEvent(last_event, new_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 void EventRewriter::BuildRewrittenKeyEvent(
     const ui::KeyEvent& key_event,
     const MutableKeyState& state,
     std::unique_ptr<ui::Event>* rewritten_event) {
   ui::KeyEvent* rewritten_key_event =
@@ skipping 132 matching lines @@
       // Early exit with completed event.
       BuildRewrittenKeyEvent(key_event, state, rewritten_event);
       return ui::EVENT_REWRITE_REWRITTEN;
     }
     RewriteNumPadKeys(key_event, &state);
   }
 
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   bool is_sticky_key_extension_command = false;
   if (sticky_keys_controller_) {
-    status = sticky_keys_controller_->RewriteKeyEvent(key_event, state.key_code,
-                                                      &state.flags);
+    std::unique_ptr<ui::Event> tmp_event = ui::Event::Clone(key_event);

[sadrul, 2017/03/09 06:28:12]

Can you simply make a copy, i.e:

  ui::KeyEvent tmp_event = key_event;

[Peng, 2017/03/09 15:56:47]

Done.

+    tmp_event->AsKeyEvent()->set_key_code(state.key_code);
+    tmp_event->AsKeyEvent()->set_flags(state.flags);
+    std::unique_ptr<ui::Event> output_event;
+    status = sticky_keys_controller_->RewriteEvent(*tmp_event, &output_event);
+    if (status == ui::EVENT_REWRITE_REWRITTEN ||
+        status == ui::EVENT_REWRITE_DISPATCH_ANOTHER)
+      state.flags = output_event->flags();
     if (status == ui::EVENT_REWRITE_DISCARD)
       return ui::EVENT_REWRITE_DISCARD;
     is_sticky_key_extension_command =
         IsExtensionCommandRegistered(state.key_code, state.flags);
   }
 
   // If flags have changed, this may change the interpretation of the key,
   // so reapply layout.
   if (state.flags != key_event.flags())
     SetMeaningForLayout(key_event.type(), &state);
@@ skipping 28 matching lines @@
   BuildRewrittenKeyEvent(key_event, state, rewritten_event);
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent(
     const ui::MouseEvent& mouse_event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   int flags = mouse_event.flags();
   RewriteLocatedEvent(mouse_event, &flags);
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
-  if (sticky_keys_controller_)
-    status = sticky_keys_controller_->RewriteMouseEvent(mouse_event, &flags);
+  if (sticky_keys_controller_) {
+    std::unique_ptr<ui::Event> tmp_event = ui::Event::Clone(mouse_event);

[sadrul, 2017/03/09 06:28:13]

Just make a copy, as above?

[Peng, 2017/03/09 15:56:47]

Done.

+    tmp_event->set_flags(flags);
+    std::unique_ptr<ui::Event> output_event;
+    status = sticky_keys_controller_->RewriteEvent(*tmp_event, &output_event);
+    if (status == ui::EVENT_REWRITE_REWRITTEN ||
+        status == ui::EVENT_REWRITE_DISPATCH_ANOTHER)
+      flags = output_event->flags();
+  }
   int changed_button = ui::EF_NONE;
   if ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
       (mouse_event.type() == ui::ET_MOUSE_RELEASED)) {
     changed_button = RewriteModifierClick(mouse_event, &flags);
   }
   if ((mouse_event.flags() == flags) &&
       (status == ui::EVENT_REWRITE_CONTINUE)) {
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (status == ui::EVENT_REWRITE_CONTINUE)
@@ skipping 13 matching lines @@
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseWheelEvent(
     const ui::MouseWheelEvent& wheel_event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   if (!sticky_keys_controller_)
     return ui::EVENT_REWRITE_CONTINUE;
   int flags = wheel_event.flags();
   RewriteLocatedEvent(wheel_event, &flags);
+  std::unique_ptr<ui::Event> tmp_event = ui::Event::Clone(wheel_event);
+  tmp_event->set_flags(flags);
   ui::EventRewriteStatus status =
-      sticky_keys_controller_->RewriteMouseEvent(wheel_event, &flags);
-  if ((wheel_event.flags() == flags) &&
-      (status == ui::EVENT_REWRITE_CONTINUE)) {
-    return ui::EVENT_REWRITE_CONTINUE;
+      sticky_keys_controller_->RewriteEvent(*tmp_event, rewritten_event);
+
+  switch (status) {
+    case ui::EVENT_REWRITE_REWRITTEN:
+    case ui::EVENT_REWRITE_DISPATCH_ANOTHER:
+// whell event has been rewritten and stored in |rewritten_event|.

[sadrul, 2017/03/09 06:28:12]

indentation seems off here.

[Peng, 2017/03/09 15:56:47]

Done.

+#if defined(USE_X11)
+      ui::UpdateX11EventForFlags(rewritten_event->get());
+#endif
+      break;
+    case ui::EVENT_REWRITE_CONTINUE:
+      if (flags != wheel_event.flags()) {
+        *rewritten_event = base::MakeUnique<ui::MouseWheelEvent>(wheel_event);
+        (*rewritten_event)->set_flags(flags);
+        status = ui::EVENT_REWRITE_REWRITTEN;
+#if defined(USE_X11)
+        ui::UpdateX11EventForFlags(rewritten_event->get());
+#endif

[sadrul, 2017/03/09 06:28:12]

Can you remove the USE_X11 changes? Because those are no longer used on any
device. If it breaks some unit-tests, then it's probably a better idea to remove
those tests too. Or may be do that in a separate CL ... I am OK with that too.

[Peng, 2017/03/09 15:56:46]

I tried, but seems linux_chromium_chromeos_rel_ng are still using X11 for
chromeos. some test cases failed without those code. I will remove them in
separate CL later. 

I am thinking why we still need this bot if we don't use X11 for chromeos
anymore.

+      }
+      break;
+    case ui::EVENT_REWRITE_DISCARD:
+      NOTREACHED();
+      break;
   }
-  if (status == ui::EVENT_REWRITE_CONTINUE)
-    status = ui::EVENT_REWRITE_REWRITTEN;
-  ui::MouseWheelEvent* rewritten_wheel_event =
-      new ui::MouseWheelEvent(wheel_event);
-  rewritten_event->reset(rewritten_wheel_event);
-  rewritten_wheel_event->set_flags(flags);
-#if defined(USE_X11)
-  ui::UpdateX11EventForFlags(rewritten_wheel_event);
-#endif
+
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteTouchEvent(
     const ui::TouchEvent& touch_event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   int flags = touch_event.flags();
   RewriteLocatedEvent(touch_event, &flags);
   if (touch_event.flags() == flags)
     return ui::EVENT_REWRITE_CONTINUE;
   ui::TouchEvent* rewritten_touch_event = new ui::TouchEvent(touch_event);
   rewritten_event->reset(rewritten_touch_event);
   rewritten_touch_event->set_flags(flags);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(rewritten_touch_event);
 #endif
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteScrollEvent(
     const ui::ScrollEvent& scroll_event,
     std::unique_ptr<ui::Event>* rewritten_event) {
-  int flags = scroll_event.flags();
-  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
-  if (sticky_keys_controller_)
-    status = sticky_keys_controller_->RewriteScrollEvent(scroll_event, &flags);
-  if (status == ui::EVENT_REWRITE_CONTINUE)
-    return status;
-  ui::ScrollEvent* rewritten_scroll_event = new ui::ScrollEvent(scroll_event);
-  rewritten_event->reset(rewritten_scroll_event);
-  rewritten_scroll_event->set_flags(flags);
+  if (!sticky_keys_controller_)
+    return ui::EVENT_REWRITE_CONTINUE;
+  ui::EventRewriteStatus status =
+      sticky_keys_controller_->RewriteEvent(scroll_event, rewritten_event);
+  // Scroll event shouldn't be discarded.
+  DCHECK_NE(status, ui::EVENT_REWRITE_DISCARD);
 #if defined(USE_X11)
-  ui::UpdateX11EventForFlags(rewritten_scroll_event);
+  if (status != ui::EVENT_REWRITE_CONTINUE)
+    ui::UpdateX11EventForFlags(rewritten_event->get());
 #endif
   return status;
 }
 
 bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
                                         MutableKeyState* state) {
   DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
          key_event.type() == ui::ET_KEY_RELEASED);
 
   // Do nothing if we have just logged in as guest but have not restarted chrome
@@ skipping 498 matching lines @@
   for (const auto& keyboard : keyboard_devices) {
     if (keyboard.id == device_id) {
       return KeyboardDeviceAddedInternal(
           keyboard.id, keyboard.name, keyboard.vendor_id, keyboard.product_id);
     }
   }
   return kDeviceUnknown;
 }
 
 }  // namespace chromeos