Do not use ash in chromeos::EventRewriter.

chrome/browser/chromeos/events/event_rewriter.cc

Index: chrome/browser/chromeos/events/event_rewriter.cc
diff --git a/chrome/browser/chromeos/events/event_rewriter.cc b/chrome/browser/chromeos/events/event_rewriter.cc
index 5a68721e218eae08058ef9c1c5d5a96fa078ed47..be4e6d7f8ec962cfcd79af646f2b48ce74261ac2 100644
--- a/chrome/browser/chromeos/events/event_rewriter.cc
+++ b/chrome/browser/chromeos/events/event_rewriter.cc
@@ -8,9 +8,6 @@
 
 #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"
@@ -37,18 +34,6 @@
 #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"
-#include "ui/events/keycodes/keyboard_code_conversion_x.h"
-#endif
-
 namespace chromeos {
 
 namespace {
@@ -306,7 +291,7 @@ ui::DomCode RelocateModifier(ui::DomCode code, ui::DomKeyLocation location) {
 
 }  // 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),
@@ -370,7 +355,7 @@ ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
     // 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;
@@ -523,8 +508,13 @@ ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
   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);
+    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)
+      state.flags = output_event->flags();
     if (status == ui::EVENT_REWRITE_DISCARD)
       return ui::EVENT_REWRITE_DISCARD;
     is_sticky_key_extension_command =
@@ -545,15 +535,6 @@ ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
   }
   if ((key_event.flags() == state.flags) &&
       (key_event.key_code() == state.key_code) &&
-#if defined(USE_X11)
-      // TODO(kpschoedel): This test is present because several consumers of
-      // key events depend on having a native core X11 event, so we rewrite
-      // all XI2 key events (GenericEvent) into corresponding core X11 key
-      // events. Remove this when event consumers no longer care about
-      // native X11 event details (crbug.com/380349).
-      (!key_event.HasNativeEvent() ||
-       (key_event.native_event()->type != GenericEvent)) &&
-#endif
       (status == ui::EVENT_REWRITE_CONTINUE)) {
     return ui::EVENT_REWRITE_CONTINUE;
   }
@@ -573,8 +554,14 @@ ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent(
   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);
+    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)
+      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)) {
@@ -589,14 +576,8 @@ ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent(
   ui::MouseEvent* rewritten_mouse_event = new ui::MouseEvent(mouse_event);
   rewritten_event->reset(rewritten_mouse_event);
   rewritten_mouse_event->set_flags(flags);
-#if defined(USE_X11)
-  ui::UpdateX11EventForFlags(rewritten_mouse_event);
-#endif
   if (changed_button != ui::EF_NONE) {
     rewritten_mouse_event->set_changed_button_flags(changed_button);
-#if defined(USE_X11)
-    ui::UpdateX11EventForChangedButtonFlags(rewritten_mouse_event);
-#endif
   }
   return status;
 }
@@ -608,21 +589,22 @@ ui::EventRewriteStatus EventRewriter::RewriteMouseWheelEvent(
     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);
+  std::unique_ptr<ui::Event> output_event;
   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;
-  }
-  if (status == ui::EVENT_REWRITE_CONTINUE)
+      sticky_keys_controller_->RewriteEvent(*tmp_event, &output_event);
+  if (status == ui::EVENT_REWRITE_REWRITTEN) {
+    flags = output_event->flags();
+  } else if (status == ui::EVENT_REWRITE_CONTINUE) {
+    if (wheel_event.flags() == flags)
+      return 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;
 }
 
@@ -636,28 +618,15 @@ ui::EventRewriteStatus EventRewriter::RewriteTouchEvent(
   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 defined(USE_X11)
-  ui::UpdateX11EventForFlags(rewritten_scroll_event);
-#endif
-  return status;
+  if (!sticky_keys_controller_)
+    return ui::EVENT_REWRITE_CONTINUE;
+  return sticky_keys_controller_->RewriteEvent(scroll_event, rewritten_event);
 }
 
 bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
@@ -728,7 +697,6 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
       if (remapped_key && remapped_key->result.key_code == ui::VKEY_CAPITAL)
         remapped_key = kModifierRemappingNeoMod3;
       break;
-#if !defined(USE_X11)
     case ui::DomKey::ALT_GRAPH_LATCH:
       if (key_event.type() == ui::ET_KEY_PRESSED) {
         pressed_modifier_latches_ |= ui::EF_ALTGR_DOWN;
@@ -748,7 +716,6 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
       state->key_code = ui::VKEY_ALTGR;
       exact_event = true;
       break;
-#endif
     default:
       break;
   }
@@ -844,12 +811,6 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
     if (state->key_code == ui::VKEY_CAPITAL
         // ... except on linux Chrome OS, where InputMethodChromeOS handles it.
         && (base::SysInfo::IsRunningOnChromeOS() || ime_keyboard_for_testing_)
-#if defined(USE_X11)
-        // ... but for X11, do nothing if the original key is ui::VKEY_CAPITAL
-        // (i.e. a Caps Lock key on an external keyboard is pressed) since X
-        // handles that itself.
-        && incoming.key_code != ui::VKEY_CAPITAL
-#endif
         ) {
       chromeos::input_method::ImeKeyboard* ime_keyboard =
           ime_keyboard_for_testing_