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"
-#include "ui/events/keycodes/keyboard_code_conversion_x.h"
-#endif
-
 namespace chromeos {
 
 namespace {
 
 // Hotrod controller vendor/product ids.
 const int kHotrodRemoteVendorId = 0x0471;
 const int kHotrodRemoteProductId = 0x21cc;
 const int kUnknownVendorId = -1;
 const int kUnknownProductId = -1;
 
@@ skipping 237 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);
+    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 =
         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);
 
   // If sticky key rewrites the event, and it matches an extension command, do
   // not further rewrite the event since it won't match the extension command
   // thereafter.
   if (!is_sticky_key_extension_command && !(key_event.flags() & ui::EF_FINAL)) {
     RewriteExtendedKeys(key_event, &state);
     RewriteFunctionKeys(key_event, &state);
   }
   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;
   }
   // Sticky keys may have returned a result other than |EVENT_REWRITE_CONTINUE|,
   // in which case we need to preserve that return status. Alternatively, we
   // might be here because key_event changed, in which case we need to
   // return |EVENT_REWRITE_REWRITTEN|.
   if (status == ui::EVENT_REWRITE_CONTINUE)
     status = ui::EVENT_REWRITE_REWRITTEN;
   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);
+    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)) {
     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)
     status = ui::EVENT_REWRITE_REWRITTEN;
   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;
 }
 
 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);
+  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;
+      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;
   }
-  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 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,
                                         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
   // process yet (so we are still on the login screen). In this situations we
   // have no user profile so can not do anything useful.
@@ skipping 50 matching lines @@
               GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
         } else {
           characteristic_flag = ui::EF_ALTGR_DOWN;
           remapped_key =
               GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
         }
       }
       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;
       } else {
         pressed_modifier_latches_ &= ~ui::EF_ALTGR_DOWN;
         if (used_modifier_latches_ & ui::EF_ALTGR_DOWN)
           used_modifier_latches_ &= ~ui::EF_ALTGR_DOWN;
         else
           latched_modifier_latches_ |= ui::EF_ALTGR_DOWN;
       }
       // Rewrite to AltGraph. When this key is used like a regular modifier,
       // the web-exposed result looks like a use of the regular modifier.
       // When it's used as a latch, the web-exposed result is a vacuous
       // modifier press-and-release, which should be harmless, but preserves
       // the event for applications using the |code| (e.g. remoting).
       state->key = ui::DomKey::ALT_GRAPH;
       state->key_code = ui::VKEY_ALTGR;
       exact_event = true;
       break;
-#endif
     default:
       break;
   }
 
   // Remapping based on DomCode.
   switch (incoming.code) {
     // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock
     // is pressed (with one exception: when
     // IsISOLevel5ShiftUsedByCurrentInputMethod() is true, the key generates
     // XK_ISO_Level3_Shift with Mod3Mask, not XF86XK_Launch7).
@@ skipping 75 matching lines @@
 
   if (key_event.type() == ui::ET_KEY_PRESSED) {
     if (!ui::KeycodeConverter::IsDomKeyForModifier(state->key)) {
       used_modifier_latches_ |= pressed_modifier_latches_;
       latched_modifier_latches_ = ui::EF_NONE;
     }
     // Toggle Caps Lock if the remapped key is ui::VKEY_CAPITAL.
     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_
               ? ime_keyboard_for_testing_
               : chromeos::input_method::InputMethodManager::Get()
                     ->GetImeKeyboard();
       ime_keyboard->SetCapsLockEnabled(!ime_keyboard->CapsLockIsEnabled());
     }
   }
   return exact_event;
@@ skipping 304 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