Revert 278342 "Convert sticky keys to a chromeos::EventRewriter ..."

trunk/src/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 <vector>
 
-#include "ash/sticky_keys/sticky_keys_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
@@ skipping 123 matching lines @@
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(flags); ++i) {
     if (ui_flags & flags[i].ui)
       *x_flags |= flags[i].x;
     else
       *x_flags &= ~flags[i].x;
   }
 }
 #endif
 
-bool IsSendEvent(const ui::Event& event) {
-#if defined(USE_X11)
-  // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
-  // crbug.com/136465.
-  XEvent* xev = event.native_event();
-  if (xev && xev->xany.send_event)
-    return true;
-#endif
-  return false;
-}
-
 }  // namespace
 
-EventRewriter::EventRewriter(ash::StickyKeysController* sticky_keys_controller)
+EventRewriter::EventRewriter()
     : last_device_id_(kBadDeviceId),
       ime_keyboard_for_testing_(NULL),
-      pref_service_for_testing_(NULL),
-      sticky_keys_controller_(sticky_keys_controller) {
+      pref_service_for_testing_(NULL) {
 #if defined(USE_X11)
   ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
   if (base::SysInfo::IsRunningOnChromeOS()) {
     XInputHierarchyChangedEventListener::GetInstance()->AddObserver(this);
   }
 #endif
 }
 
 EventRewriter::~EventRewriter() {
 #if defined(USE_X11)
@@ skipping 11 matching lines @@
 }
 
 void EventRewriter::RewriteLocatedEventForTesting(const ui::Event& event,
                                                   int* flags) {
   RewriteLocatedEvent(event, flags);
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
-  if ((event.type() == ui::ET_KEY_PRESSED) ||
-      (event.type() == ui::ET_KEY_RELEASED)) {
-    return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event),
-                           rewritten_event);
+#if defined(USE_X11)
+  // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
+  // crbug.com/136465.
+  XEvent* xev = event.native_event();
+  if (xev && xev->xany.send_event)
+    return ui::EVENT_REWRITE_CONTINUE;
+#endif
+  switch (event.type()) {
+    case ui::ET_KEY_PRESSED:
+    case ui::ET_KEY_RELEASED:
+      return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event),
+                             rewritten_event);
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_RELEASED:
+      return RewriteMouseEvent(static_cast<const ui::MouseEvent&>(event),
+                               rewritten_event);
+    case ui::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_RELEASED:
+      return RewriteTouchEvent(static_cast<const ui::TouchEvent&>(event),
+                               rewritten_event);
+    default:
+      return ui::EVENT_REWRITE_CONTINUE;
   }
-  if (event.IsMouseEvent()) {
-    return RewriteMouseEvent(static_cast<const ui::MouseEvent&>(event),
-                             rewritten_event);
-  }
-  if ((event.type() == ui::ET_TOUCH_PRESSED) ||
-      (event.type() == ui::ET_TOUCH_RELEASED)) {
-    return RewriteTouchEvent(static_cast<const ui::TouchEvent&>(event),
-                             rewritten_event);
-  }
-  if (event.IsScrollEvent()) {
-    return RewriteScrollEvent(static_cast<const ui::ScrollEvent&>(event),
-                              rewritten_event);
-  }
-  return ui::EVENT_REWRITE_CONTINUE;
+  NOTREACHED();
 }
 
 ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
     const ui::Event& last_event,
     scoped_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);
-  }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 #if defined(USE_X11)
 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
   if (!device_id_to_type_.count(device_id)) {
     // |device_id| is unknown. This means the device was connected before
     // booting the OS. Query the name of the device and add it to the map.
     DeviceAdded(device_id);
@@ skipping 94 matching lines @@
     remapped_state->flags = (input.flags & ~map.input_flags) | map.output_flags;
     return true;
   }
   return false;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     const ui::KeyEvent& key_event,
     scoped_ptr<ui::Event>* rewritten_event) {
   MutableKeyState state = {key_event.flags(), key_event.key_code()};
-  bool is_send_event = IsSendEvent(key_event);
-  if (!is_send_event) {
-    RewriteModifierKeys(key_event, &state);
-    RewriteNumPadKeys(key_event, &state);
-  }
-  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
-  if (sticky_keys_controller_) {
-    status = sticky_keys_controller_->RewriteKeyEvent(
-        key_event, state.key_code, &state.flags);
-    if (status == ui::EVENT_REWRITE_DISCARD)
-      return ui::EVENT_REWRITE_DISCARD;
-  }
-  if (!is_send_event) {
-    RewriteExtendedKeys(key_event, &state);
-    RewriteFunctionKeys(key_event, &state);
-  }
+  RewriteModifierKeys(key_event, &state);
+  RewriteNumPadKeys(key_event, &state);
+  RewriteExtendedKeys(key_event, &state);
+  RewriteFunctionKeys(key_event, &state);
   if ((key_event.flags() == state.flags) &&
-      (key_event.key_code() == state.key_code) &&
-      (status == ui::EVENT_REWRITE_CONTINUE)) {
+      (key_event.key_code() == state.key_code)) {
     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;
   ui::KeyEvent* rewritten_key_event = new ui::KeyEvent(key_event);
   rewritten_event->reset(rewritten_key_event);
   rewritten_key_event->set_flags(state.flags);
   rewritten_key_event->set_key_code(state.key_code);
   rewritten_key_event->set_character(
       ui::GetCharacterFromKeyCode(state.key_code, state.flags));
   rewritten_key_event->NormalizeFlags();
 #if defined(USE_X11)
   XEvent* xev = rewritten_key_event->native_event();
   if (xev) {
     CHECK(xev->type == KeyPress || xev->type == KeyRelease);
     XKeyEvent* xkey = &(xev->xkey);
     UpdateX11EventMask(rewritten_key_event->flags(), &xkey->state);
     xkey->keycode =
         XKeysymToKeycode(gfx::GetXDisplay(),
                          ui::XKeysymForWindowsKeyCode(
                              state.key_code, state.flags & ui::EF_SHIFT_DOWN));
   }
 #endif
-  return status;
+  return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseEvent(
     const ui::MouseEvent& mouse_event,
     scoped_ptr<ui::Event>* rewritten_event) {
   int flags = mouse_event.flags();
-  if ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
-      (mouse_event.type() == ui::ET_MOUSE_RELEASED)) {
-    RewriteLocatedEvent(mouse_event, &flags);
-  }
-  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
-  if (sticky_keys_controller_)
-    status = sticky_keys_controller_->RewriteMouseEvent(mouse_event, &flags);
-  if ((mouse_event.flags() == flags) &&
-      (status == ui::EVENT_REWRITE_CONTINUE)) {
+  RewriteLocatedEvent(mouse_event, &flags);
+  if (mouse_event.flags() == flags)
     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)
   XEvent* xev = rewritten_mouse_event->native_event();
   if (xev) {
     switch (xev->type) {
       case ButtonPress:
       case ButtonRelease: {
         XButtonEvent* xbutton = &(xev->xbutton);
         UpdateX11EventMask(rewritten_mouse_event->flags(), &xbutton->state);
         break;
       }
       case GenericEvent: {
         XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
         CHECK(xievent->evtype == XI_ButtonPress ||
               xievent->evtype == XI_ButtonRelease);
         UpdateX11EventMask(
             rewritten_mouse_event->flags(),
             reinterpret_cast<unsigned int*>(&xievent->mods.effective));
         break;
       }
       default:
         NOTREACHED();
     }
   }
 #endif
-  return status;
+  return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteTouchEvent(
     const ui::TouchEvent& touch_event,
     scoped_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)
   XEvent* xev = rewritten_touch_event->native_event();
   if (xev) {
     XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
     if (xievent) {
       UpdateX11EventMask(
           rewritten_touch_event->flags(),
           reinterpret_cast<unsigned int*>(&xievent->mods.effective));
     }
   }
 #endif
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
-ui::EventRewriteStatus EventRewriter::RewriteScrollEvent(
-    const ui::ScrollEvent& scroll_event,
-    scoped_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)
-  XEvent* xev = rewritten_scroll_event->native_event();
-  if (xev) {
-    XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
-    if (xievent) {
-      UpdateX11EventMask(
-          rewritten_scroll_event->flags(),
-          reinterpret_cast<unsigned int*>(&xievent->mods.effective));
-    }
-  }
-#endif
-  return status;
-}
-
 void 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.
   // Note that currently, unlike other accounts, when user logs in as guest, we
   // restart chrome process. In future this is to be changed.
@@ skipping 377 matching lines @@
 
   XIFreeDeviceInfo(device_info);
 }
 
 void EventRewriter::DeviceRemoved(int device_id) {
   device_id_to_type_.erase(device_id);
 }
 #endif
 
 }  // namespace chromeos