Do not use ash in chromeos::EventRewriter.

ash/sticky_keys/sticky_keys_controller.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #include "ash/sticky_keys/sticky_keys_overlay.h"
 #include "base/debug/stack_trace.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 namespace ash {
 
 namespace {
 
 // Returns true if the type of mouse event should be modified by sticky keys.
 bool ShouldModifyMouseEvent(const ui::MouseEvent& event) {
   ui::EventType type = event.type();
   return type == ui::ET_MOUSE_PRESSED || type == ui::ET_MOUSE_RELEASED ||
          type == ui::ET_MOUSEWHEEL;
 }
 
 // Handle the common tail of event rewriting.
-ui::EventRewriteStatus RewriteUpdate(bool consumed,
-                                     bool released,
-                                     int mod_down_flags,
-                                     int* flags) {
-  int changed_down_flags = mod_down_flags & ~*flags;
-  *flags |= mod_down_flags;
+ui::EventRewriteStatus RewriteUpdate(
+    bool consumed,
+    bool released,
+    int mod_down_flags,
+    const ui::Event& event,
+    std::unique_ptr<ui::Event>* rewritten_event) {
+  int changed_down_flags = mod_down_flags & event.flags();
   if (consumed)
     return ui::EVENT_REWRITE_DISCARD;
   if (released)
     return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
-  if (changed_down_flags)
+  if (changed_down_flags) {
+    *rewritten_event = ui::Event::Clone(event);
+    (*rewritten_event)->set_flags(event.flags() | mod_down_flags);
     return ui::EVENT_REWRITE_REWRITTEN;
+  }
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeys
 StickyKeysController::StickyKeysController()
     : enabled_(false), mod3_enabled_(false), altgr_enabled_(false) {}
 
@@ skipping 25 matching lines @@
 void StickyKeysController::SetModifiersEnabled(bool mod3_enabled,
                                                bool altgr_enabled) {
   mod3_enabled_ = mod3_enabled;
   altgr_enabled_ = altgr_enabled;
   if (overlay_) {
     overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
     overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
   }
 }
 
+StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
+  return overlay_.get();
+}
+
+ui::EventRewriteStatus StickyKeysController::RewriteEvent(
+    const ui::Event& event,
+    std::unique_ptr<ui::Event>* rewritten_event) {
+  DCHECK(rewritten_event);
+  if (!enabled_)
+    return ui::EVENT_REWRITE_CONTINUE;
+
+  if (event.IsKeyEvent()) {
+    int mod_down_flags = 0;
+    bool released = false;
+    bool consumed =
+        HandleKeyEvent(*event.AsKeyEvent(), &mod_down_flags, &released);
+    UpdateOverlay();
+    return RewriteUpdate(consumed, released, mod_down_flags, event,
+                         rewritten_event);
+  } else if (event.IsMouseEvent()) {
+    int mod_down_flags = 0;
+    bool released = false;
+    bool consumed =
+        HandleMouseEvent(*event.AsMouseEvent(), &mod_down_flags, &released);
+    UpdateOverlay();
+    return RewriteUpdate(consumed, released, mod_down_flags, event,
+                         rewritten_event);
+  } else if (event.IsScrollEvent()) {
+    int mod_down_flags = 0;
+    bool released = false;
+    bool consumed =
+        HandleScrollEvent(*event.AsScrollEvent(), &mod_down_flags, &released);
+    UpdateOverlay();
+    return RewriteUpdate(consumed, released, mod_down_flags, event,
+                         rewritten_event);
+  }
+  NOTREACHED();
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+ui::EventRewriteStatus StickyKeysController::NextDispatchEvent(
+    const ui::Event& last_event,
+    std::unique_ptr<ui::Event>* new_event) {
+  DCHECK(new_event);
+  new_event->reset();
+  int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) +
+                  alt_sticky_key_->GetModifierUpEvent(new_event) +
+                  altgr_sticky_key_->GetModifierUpEvent(new_event) +
+                  ctrl_sticky_key_->GetModifierUpEvent(new_event) +
+                  mod3_sticky_key_->GetModifierUpEvent(new_event) +
+                  search_sticky_key_->GetModifierUpEvent(new_event);
+  if (!new_event)
+    return ui::EVENT_REWRITE_CONTINUE;
+  if (remaining)
+    return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
+  return ui::EVENT_REWRITE_REWRITTEN;
+}
+
 bool StickyKeysController::HandleKeyEvent(const ui::KeyEvent& event,
-                                          ui::KeyboardCode key_code,
                                           int* mod_down_flags,
                                           bool* released) {
-  return shift_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                           released) ||
-         alt_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                         released) ||
-         altgr_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                           released) ||
-         ctrl_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                          released) ||
-         mod3_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                          released) ||
-         search_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
-                                            released);
+  return shift_sticky_key_->HandleKeyEvent(event, mod_down_flags, released) ||
+         alt_sticky_key_->HandleKeyEvent(event, mod_down_flags, released) ||
+         altgr_sticky_key_->HandleKeyEvent(event, mod_down_flags, released) ||
+         ctrl_sticky_key_->HandleKeyEvent(event, mod_down_flags, released) ||
+         mod3_sticky_key_->HandleKeyEvent(event, mod_down_flags, released) ||
+         search_sticky_key_->HandleKeyEvent(event, mod_down_flags, released);
 }
 
 bool StickyKeysController::HandleMouseEvent(const ui::MouseEvent& event,
                                             int* mod_down_flags,
                                             bool* released) {
   return shift_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
          alt_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
          altgr_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
          ctrl_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
          mod3_sticky_key_->HandleMouseEvent(event, mod_down_flags, released);
 }
 
 bool StickyKeysController::HandleScrollEvent(const ui::ScrollEvent& event,
                                              int* mod_down_flags,
                                              bool* released) {
   return shift_sticky_key_->HandleScrollEvent(event, mod_down_flags,
                                               released) ||
          alt_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) ||
          altgr_sticky_key_->HandleScrollEvent(event, mod_down_flags,
                                               released) ||
          ctrl_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) ||
          mod3_sticky_key_->HandleScrollEvent(event, mod_down_flags, released);
 }
 
-ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent(

[Tim Song, 2017/03/07 18:48:54]

Could you keep these functions (but make them private) and call them from
RewriteEvent()? It's easier to read than a large if statement of complex logic.

[Peng, 2017/03/07 19:43:16]

Done

-    const ui::KeyEvent& event,
-    ui::KeyboardCode key_code,
-    int* flags) {
-  if (!enabled_)
-    return ui::EVENT_REWRITE_CONTINUE;
-  int mod_down_flags = 0;
-  bool released = false;
-  bool consumed = HandleKeyEvent(event, key_code, &mod_down_flags, &released);
-  UpdateOverlay();
-  return RewriteUpdate(consumed, released, mod_down_flags, flags);
-}
-
-ui::EventRewriteStatus StickyKeysController::RewriteMouseEvent(
-    const ui::MouseEvent& event,
-    int* flags) {
-  if (!enabled_)
-    return ui::EVENT_REWRITE_CONTINUE;
-  int mod_down_flags = 0;
-  bool released = false;
-  bool consumed = HandleMouseEvent(event, &mod_down_flags, &released);
-  UpdateOverlay();
-  return RewriteUpdate(consumed, released, mod_down_flags, flags);
-}
-
-ui::EventRewriteStatus StickyKeysController::RewriteScrollEvent(
-    const ui::ScrollEvent& event,
-    int* flags) {
-  if (!enabled_)
-    return ui::EVENT_REWRITE_CONTINUE;
-  int mod_down_flags = 0;
-  bool released = false;
-  bool consumed = HandleScrollEvent(event, &mod_down_flags, &released);
-  UpdateOverlay();
-  return RewriteUpdate(consumed, released, mod_down_flags, flags);
-}
-
-ui::EventRewriteStatus StickyKeysController::NextDispatchEvent(
-    std::unique_ptr<ui::Event>* new_event) {
-  DCHECK(new_event);
-  new_event->reset();
-  int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) +
-                  alt_sticky_key_->GetModifierUpEvent(new_event) +
-                  altgr_sticky_key_->GetModifierUpEvent(new_event) +
-                  ctrl_sticky_key_->GetModifierUpEvent(new_event) +
-                  mod3_sticky_key_->GetModifierUpEvent(new_event) +
-                  search_sticky_key_->GetModifierUpEvent(new_event);
-  if (!new_event)
-    return ui::EVENT_REWRITE_CONTINUE;
-  if (remaining)
-    return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
-  return ui::EVENT_REWRITE_REWRITTEN;
-}
-
 void StickyKeysController::UpdateOverlay() {
   overlay_->SetModifierKeyState(ui::EF_SHIFT_DOWN,
                                 shift_sticky_key_->current_state());
   overlay_->SetModifierKeyState(ui::EF_CONTROL_DOWN,
                                 ctrl_sticky_key_->current_state());
   overlay_->SetModifierKeyState(ui::EF_ALT_DOWN,
                                 alt_sticky_key_->current_state());
   overlay_->SetModifierKeyState(ui::EF_COMMAND_DOWN,
                                 search_sticky_key_->current_state());
   overlay_->SetModifierKeyState(ui::EF_ALTGR_DOWN,
                                 altgr_sticky_key_->current_state());
   overlay_->SetModifierKeyState(ui::EF_MOD3_DOWN,
                                 mod3_sticky_key_->current_state());
 
   bool key_in_use =
       shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       search_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;
 
   overlay_->Show(enabled_ && key_in_use);
 }
 
-StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
-  return overlay_.get();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeysHandler
 StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag)
     : modifier_flag_(modifier_flag),
       current_state_(STICKY_KEY_STATE_DISABLED),
       preparing_to_enable_(false),
       scroll_delta_(0) {}
 
 StickyKeysHandler::~StickyKeysHandler() {}
 
 bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event,
-                                       ui::KeyboardCode key_code,
                                        int* mod_down_flags,
                                        bool* released) {
   switch (current_state_) {
     case STICKY_KEY_STATE_DISABLED:
-      return HandleDisabledState(event, key_code);
+      return HandleDisabledState(event);
     case STICKY_KEY_STATE_ENABLED:
-      return HandleEnabledState(event, key_code, mod_down_flags, released);
+      return HandleEnabledState(event, mod_down_flags, released);
     case STICKY_KEY_STATE_LOCKED:
-      return HandleLockedState(event, key_code, mod_down_flags, released);
+      return HandleLockedState(event, mod_down_flags, released);
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleMouseEvent(const ui::MouseEvent& event,
                                          int* mod_down_flags,
                                          bool* released) {
   if (ShouldModifyMouseEvent(event))
     preparing_to_enable_ = false;
@@ skipping 88 matching lines @@
     return type == ui::ET_KEY_PRESSED ? NORMAL_KEY_DOWN : NORMAL_KEY_UP;
   }
 
   if (is_target_key) {
     return type == ui::ET_KEY_PRESSED ? TARGET_MODIFIER_DOWN
                                       : TARGET_MODIFIER_UP;
   }
   return type == ui::ET_KEY_PRESSED ? OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
 }
 
-bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event,
-                                            ui::KeyboardCode key_code) {
-  switch (TranslateKeyEvent(event.type(), key_code)) {
+bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event) {
+  switch (TranslateKeyEvent(event.type(), event.key_code())) {
     case TARGET_MODIFIER_UP:
       if (preparing_to_enable_) {
         preparing_to_enable_ = false;
         scroll_delta_ = 0;
         current_state_ = STICKY_KEY_STATE_ENABLED;
         modifier_up_event_.reset(new ui::KeyEvent(event));
         return true;
       }
       return false;
     case TARGET_MODIFIER_DOWN:
       preparing_to_enable_ = true;
       return false;
     case NORMAL_KEY_DOWN:
       preparing_to_enable_ = false;
       return false;
     case NORMAL_KEY_UP:
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleEnabledState(const ui::KeyEvent& event,
-                                           ui::KeyboardCode key_code,
                                            int* mod_down_flags,
                                            bool* released) {
-  switch (TranslateKeyEvent(event.type(), key_code)) {
+  switch (TranslateKeyEvent(event.type(), event.key_code())) {
     case NORMAL_KEY_UP:
     case TARGET_MODIFIER_DOWN:
       return false;
     case TARGET_MODIFIER_UP:
       current_state_ = STICKY_KEY_STATE_LOCKED;
       modifier_up_event_.reset();
       return true;
     case NORMAL_KEY_DOWN: {
       current_state_ = STICKY_KEY_STATE_DISABLED;
       *mod_down_flags |= modifier_flag_;
       *released = true;
       return false;
     }
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleLockedState(const ui::KeyEvent& event,
-                                          ui::KeyboardCode key_code,
                                           int* mod_down_flags,
                                           bool* released) {
-  switch (TranslateKeyEvent(event.type(), key_code)) {
+  switch (TranslateKeyEvent(event.type(), event.key_code())) {
     case TARGET_MODIFIER_DOWN:
       return true;
     case TARGET_MODIFIER_UP:
       current_state_ = STICKY_KEY_STATE_DISABLED;
       return false;
     case NORMAL_KEY_DOWN:
     case NORMAL_KEY_UP:
       *mod_down_flags |= modifier_flag_;
       return false;
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace ash